创建型设计模式

单列设计模式

场景：当系统中只需要一个实例或者一个全局的访问时候
实现方式较多, 出于性能考虑 双层校验索用的更为广泛

public class EventBus{

        //volatile 作用：保证修饰的变量的可见性， 强制线程读取该值都去主内存读取， 而不是使用线程内部的变量副本。
        static volatile  EventBus defaultInstance;

        public static EventBus getDefualt(){

             EventBus instance = defaultInstance;
             if(instance == null){
                    //synchronized 对象锁， 保证每次只有一个线程执行对象初始化操作
                    synchronized (EventBus.class){
                            instance = EventBus.defaultInstance;
                            if( instance == null ){
                                    instance = EventBus.defaultInstance  = new EventBus();
                             }
                     }
            }

            return instance;
   
      }

}

建造者模式：

场景 ：封装一个复杂对象的构建与表示：

public class EventBusBuilder{

        boolean logSubscriberExceptions = true;
        boolean logNoSubscriberMessages = true;
        boolean sendSubscriberExceptionEvent = true;
        boolean sendNoSubscriberEvent = true;
        boolean throwSubscriberException;
        boolean eventInheritance = true;
        boolean ignoreGeneratedIndex;
        boolean strictMethodVerification;
        //省略部分

        /** Default: true */
        public EventBusBuilder logSubscriberExceptions(boolean logSubscriberExceptions) {
                this.logSubscriberExceptions = logSubscriberExceptions;
                return this;
        }
       //省略部分

        /** Builds an EventBus based on the current configuration. */
        public EventBus build() {
                return new EventBus(this);
        }
}

原型模式

场景：对象的数据结构或者构建过程特别复杂，避免频繁的构建消耗系统性能时候采用。

声明实现loneable接口，然后覆写Object的clone()方法接口，默认是浅拷贝，要实现深拷贝，在clone方法里对于引用对象也有调用一下clone()方法

public class Intent implements Parcelable, Cloneable {

   @Override
   public Object clone() {
       return new Intent(this);
   }

   private Intent(Intent o, boolean all) {
      this.mAction = o.mAction;
      this.mData = o.mData;
      this.mType = o.mType;
      this.mPackage = o.mPackage;
      this.mComponent = o.mComponent;
     if (o.mCategories != null) {
         this.mCategories = new ArraySet<String>(o.mCategories);
     }
  }

}

简单工厂模式：

根据往工厂的static方法传入的参数决定实例化哪个对象：

角色说明：
Product(抽象产品类)：定义对象的公共接口
ConcreteProduct(具体产品类)：实现Product接口
Factory(工厂类)： 返回ConcreteProduct实例

缺点违背开放封闭原则， 如果需要添加新产品则必须修改工厂类逻辑；因此还可以用反射来创建实例对象

public class Factory{
        
      public static <T extends Product> T create(Class<T> clz){
           Product product = null;
           try {
                product = (Product) Class.forName(clz.getName()).newInstance();//反射出实例
           } catch (Exception e) {
               e.printStackTrace();
           }
         
            return (T) product;
    
        }
}

工厂模式

创建复杂对象，无需具体的类名，只要需要相应的工厂方法即可；每个具体工厂类只能创建一个具体产品类的实例

角色说明：
Product(抽象产品类)：定义对象的公共接口
ConcreteProduct(具体产品类)：实现Product接口
Factory(抽象工厂类)： 返回一个Product类型的对象
ConcreteFactory(具体工厂类) 返回ConcreteProduct实例

java集合框架迭代器设计

//Product
public  interface Iterator<E> {

        boolean hasNext();

        E next();
}

//Factory
public interface Iterable<T>{

        Iterator<T> iterator();

}

//ConcreteProduct
public interface Collection<E> extends Iterable<E>{

}

public interface List<E> extends Collection<E>{

}

public class ArrayList<E> extends AbstractList<E> implments List<E>,RandomAccess,Cloneable,Serializable{

    ...

      public Itearator<E> iterator(){

             return new ArrayList.Itr();
      }
     

      //ConcreteProduct
      public class Itr implements Iterator<E> {

             ...
      }
    
    ...

}

工厂方法使一个类的实例化延迟到了子类。

抽象工厂模式

面对的问题是多产品等级的系统设计，即在抽象工厂里可以返回多个抽象产品类实例，解决工厂方法模式只能生产一种产品的弊端