安卓中的单例模式和工厂模式_android 工厂模式和单例模式的区别-CSDN博客

本文介绍了单例模式和工厂模式的基本概念、应用场景及优缺点。详细解释了单例模式的三种实现方式：懒汉式、加同步锁及内部类实现；工厂模式则通过标准工厂模式和简单工厂模式进行了阐述。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单例模式

简单的来说，单例模式就是提供一个实例，并且提供一个全局的访问点。

适用场景：1.应用中某个实例对象需要频繁的被访问。

2.应用中每次启动只会存在一个实例。

优点：内存中只有一个实例，减少了内存的开销，避免对资源的多重占用。

常用的三种方式：

（1）懒汉式

public class A{

/* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */

private static A instance = null;

/* 私有构造方法，防止被实例化 */

private A(){

}

/* 1:懒汉式，静态工程方法，创建实例 */

public static A getInstance(){

if(instance == null){

instance = new A()

}

return instance;

}

调用：

[java]view plain copy 
   
 Singleton.getInstance().method();

优点：延迟加载（需要时在加载）

缺点：线程不安全，在多线程中很容易出现不同步的情况

（2）加同步锁

既然线程不安全，那就加上同步锁，一种加法如下：

[java]view plain copy 
   
 
 /*2.懒汉式变种，解决线程安全问题**/  
  public static synchronized Singleton getInstance() {  
      if (instance == null) {  
          instance = new Singleton();  
      }  
      return instance;  
  }  

（3）内部类的实现

内部类是一种好的实现方式，可以推荐使用一下：

[java]view plain copy 
   
 
 public class SingletonInner {  
   
     /** 
      * 内部类实现单例模式 
      * 延迟加载，减少内存开销 
      *  
      * @author xuzhaohu 
      *  
      */  
     private static class SingletonHolder {  
         private static SingletonInner instance = new SingletonInner();  
     }  
   
     /** 
      * 私有的构造函数 
      */  
     private SingletonInner() {  
   
     }  
   
     public static SingletonInner getInstance() {  
         return SingletonHolder.instance;  
     }  
   
     protected void method() {  
         System.out.println("SingletonInner");  
     }  
 }  

调用：

[java]view plain copy 
   
 SingletonInner.getInstance().method();

优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗

工厂模式

简单来说就是给外部批量提供相同或者不同的产品，而外部不需要关心工厂是如何创建一个复杂产品的过程。所以工厂模式降低模块间的耦合，同时提高扩展性。

（1）标准工厂模式

首先先介绍一下标准的工厂方法模式,不带任何的变种.以工厂生产不同操作系统的手机为例.

建立一个产品接口,提供一个获取系统信息的方法.

[java]view plain copy 
   
 /** 
  * Created by jesse on 15-8-17. 
  */  
 public interface IPhone {  
     public void getOS();  
 }  

再根据IPhone接口实现Android,IOS,Blackberry三种手机.

[java]view plain copy 
   
 public class AndroidPhone implements IPhone {  
     private final String TAG = AndroidPhone.class.getSimpleName();  
     @Override  
     public void getOS() {  
         Log.i(TAG, "im Android");  
     }  
 }  
 public class IosPhone implements IPhone {  
     private final String TAG = IosPhone.class.getSimpleName();  
     @Override  
     public void getOS() {  
         Log.i(TAG, "im IOS");  
     }  
 }  
 public class BlackBerryPhone implements IPhone {  
     private final String TAG = BlackBerryPhone.class.getSimpleName();  
     @Override  
     public void getOS() {  
         Log.i(TAG, "im BlackBerry");  
     }  
 }  

标准的工厂方法模式都需要有抽象的工厂接口或者基类.

[java]view plain copy 
   
 public abstract class IGenerator {  
     public abstract IPhone generatePhone(String flag) throws Exception;  
 }  

通过基类或者接口来实现真实的工厂类,这里需要注意跟简单工厂模式的不同,标准的工厂方法模式里面一个工厂只生产一个产品,所以这里要根据产品的种类划分出来三个工厂,分别生产三种不同的产品.这种设计思想非常契合单一职责原则.

[java]view plain copy 
   
 public class AndroidGenerator extends IGenerator {  
     @Override  
     public IPhone generatePhone() {  
         return new AndroidPhone();  
     }  
 }  
 public class IOSGenerator extends IGenerator {  
     @Override  
     public IPhone generatePhone() {  
         return new IosPhone();  
     }  
 }  
 public class BlackberryGenerator extends IGenerator {  
     @Override  
     public IPhone generatePhone() {  
         return new BlackBerryPhone();  
     }  
 }  

在客户端从工厂中获得产品并使用的过程中都是通过接口进行访问的,在创建产品的阶段有效得降低了使用者和产品之间的耦合度.

[java]view plain copy 
   
 IPhone android, ios, bb;  
 IGenerator androidGenerator, iosGenerator, bbGenerator;  
 androidGenerator = new AndroidGenerator();  
 iosGenerator = new IOSGenerator();  
 bbGenerator = new BlackberryGenerator();  
 android = androidGenerator.generatePhone();  
 ios = iosGenerator.generatePhone();  
 bb = bbGenerator.generatePhone();  
 android.getOS();  
 ios.getOS();  
 bb.getOS();  

（2）简单工厂模式，也称为静态工厂方法模式。它不能通过继承进行扩展，如果有新增的产品，就只能在静态方法里面做修改。

因为这是静态工厂方法模式,所以工厂类就没有接口或者虚基类来提供抽象.通过不同的Flag来初始化不同的产品.

[java]view plain copy 
   
 public class PhoneGenerator{  
     public final static String GENERATE_IOS = "generate_ios";  
     public final static String GENERATE_ANDROID = "generate_android";  
     public final static String GENERATE_BLACKBERRY = "generate_blackberry";  
   
     public static IPhone generatePhone(String flag) throws Exception {  
         IPhone iPhone = null;  
         switch (flag){  
             case GENERATE_ANDROID:  
                 iPhone =  new AndroidPhone();  
                 break;  
             case GENERATE_IOS:  
                 iPhone =  new IosPhone();  
                 break;  
             case GENERATE_BLACKBERRY:  
                 iPhone =  new BlackBerryPhone();  
                 break;  
             default:  
                 throw new Exception("UNDEFINED FLAG");  
         }  
         return iPhone;  
     }  
 }  

对外部来说要使用工厂只需要把目标产品类传过去就行了.运行结果跟1)中的是一样的.

[java]view plain copy 
   
 IPhone android, ios, bb;  
 android = PhoneGenerator.generatePhone(PhoneGenerator.GENERATE_ANDROID);  
 ios = PhoneGenerator.generatePhone(PhoneGenerator.GENERATE_IOS);  
 bb = PhoneGenerator.generatePhone(PhoneGenerator.GENERATE_BLACKBERRY);  
 android.getOS();  
 ios.getOS();  
 bb.getOS(); 