设计模式汇总：创建型模式

总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。

一、简单工厂模式(SimpleFactory Method Pattern)
提供一个工厂类，在工厂类中进行条件判断，具体创建哪个产品（Product）;
一个类专门负责创建其他类的实例，具体创建什么实例由传入的参数而决定，并且这些类都共同继承于一个父类或者有共同的接口。
也称静态工厂模式（理论上其并不属于一种设计模式）
《JAVA设计模式之简单工厂模式【Simple Factory Pattern】》
简单工厂模式

代码：

interface IProduct {
    void use();
}

class ConcreteProduct1 implements IProduct {
    @Override
    public void use() {
        System.out.println("use ConcreteProduct1");
    }
}

class ConcreteProduct2 implements IProduct {
    @Override
    public void use() {
        System.out.println("use ConcreteProduct2");
    }
}


class Factory {
    public static IProduct create(int which) {
        IProduct product = null;
        switch (which) {
        case 1:
            product = new ConcreteProduct1();
            break;
        case 2:
            product = new ConcreteProduct2();
            break;
        default:
            break;
        }
        return product;
    }
}

class Client {
    public void doSth() {
        IProduct product1 = Factory.create(1);
        product1.use();
    }
}

二、工厂方法模式：(Factory Method Pattern)
《工厂方法模式（Factory Method）》
工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
工厂方法模式实现时，客户端需要决定实例化哪一个工厂，决定创建哪一个类的对象，也就是说，工厂方法模式把简单工厂的内部逻辑判断移到了客户端代码来进行，本来是要改工厂类的，而现在是修改客户端。总体来说，工厂方法模式修正了简单工厂中不遵循的开放-封闭原则。

代码：

interface IProduct {
    void use();
}

class ConcreteProduct1 implements IProduct {
    @Override
    public void use() {
        System.out.println("use ConcreteProduct1");
    }
}

class ConcreteProduct2 implements IProduct {
    @Override
    public void use() {
        System.out.println("use ConcreteProduct2");
    }
}


interface IFactory {
    IProduct create();
}

class ConcreteFactory1 implements IFactory {
    @Override
    public IProduct create() {
        return new ConcreteProduct1();
    }
}

class ConcreteFactory2 implements IFactory {
    @Override
    public IProduct create() {
        return new ConcreteProduct2();
    }
}


class Client {
    public void doSth() {
        IFactory factory = new ConcreteFactory1();
        IProduct product = factory.create();
        product.use();
    }
}

三、抽象工厂模式：(Abstract Factory)
抽象工厂模式是对象的创建模式，它是工厂方法模式的进一步推广。
　　假设一个子系统需要一些产品对象，而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分割开来，可以引进抽象工厂模式。这样的话，消费产品的一方不需要直接参与产品的创建工作，而只需要向一个公用的工厂接口请求所需要的产品。
　　通过使用抽象工厂模式，可以处理具有相同（或者相似）等级结构中的多个产品族中的产品对象的创建问题。

代码：

// A产品族
interface IProductA {
    void useA();
}

class ProductA1 implements IProductA {
    @Override
    public void useA() {
        System.out.println("use ConcreteProduct1");
    }
}

class ProductA2 implements IProductA {
    @Override
    public void useA() {
        System.out.println("use ConcreteProduct2");
    }
}


// B产品族
interface IProductB {
    void useB();
}

class ProductB1 implements IProductB {
    @Override
    publicvoid useB() {
        System.out.println("useB ProductB1");
    }
}

class ProductB2 implements IProductB {
    @Override
    publicvoid useB() {
        System.out.println("useB ProductB2");
    }
}

// 生产工厂
interface IFactory {
    IProductA createA();
    IProductB createB();
}

class ConcreteFactory1 implements IFactory {

    @Override
    public IProductA createA() {
        return new ProductA1();
    }

    @Override
    public IProductB createB() {
        return new ProductB1();
    }
}

class ConcreteFactory2 implements IFactory {

    @Override
    public IProductA createA() {
        return new ProductA2();
    }

    @Override
    public IProductB createB() {
        return new ProductB2();
    }
}

// 使用对象
class Client {
    public void doSth() {
        IFactory factory = new ConcreteFactory1();
        IProductA productA = factory.createA();
        IProductB productB = factory.createB();
        productA.useA();
        productB.useB();
    }
}

三种工厂模式的区别：
简单工厂：是系统根据外界传入的具体信息创建所需的实例，等于是客户端不必关心产品如何生产，只负责指定生产什么产品。
工厂模式：让子类决定创建什么产品，即：使一个类的实例化延迟到子类。
抽象工厂模式：便于交换产品系列，同时让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端。

抽象工厂和工厂模式之间的区别：
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

四、单例模式（Singleton）:
单例模式较为简单，即保证一个类只有一个实例：

一般考察较多的是在多线程环境下的单例模式：
1）注意由于指令重排，一定要加上volatile；而且加锁要使用类锁

private static volatile TestSingleton instance = null;

public static TestSingleton getInstance() {
    if (instance == null) {
        synchronized (TestSingleton.class) {
            if (singleton == null) {
                singleton = new TestSingleton();
            }
        }
    }
    return instance;
}

2）内部类的实现方式：

public class Singleton {
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

五、建筑者模式
是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
即抽象出一个建造流程，根据需要创建出不同的对象；

//Builder接口 
interface Builder {
       // 抽象出的构造流程
       Builder BuildHead();
       Builder BuildBody();
       Builder BuildHand();
       Builder BuildFeet();
       Product GetResult();
}

class Director {
       publicProduct Construct(Builderbuilder) {
              return builder.BuildHead()
                        .BuildBody()
                     .BuildHand()
                     .BuildFeet()
                     .GetResult();
       }
}

class Product {
       private StringBufferbuffer=newStringBuffer();

       public void doSomething(Stringstr) {
              buffer.append(str);
       }

       // 显示结果
       public void display_result() {
              System.out.println(buffer.toString());
       }
}

// 具体构造的两个大人小人类
class FatBuilder implements Builder {
       private Product product = new Product();

       @Override
       public Builder BuildHead() {
              product.doSomething("FatHead+");
              return this;
       }

       @Override
       public Builder BuildBody() {
              product.doSomething("FatBody+");
              return this;
       }

       @Override
       public Builder BuildHand() {
              product.doSomething("FatHand+");
              return this;
       }

       @Override
       publicBuilder BuildFeet() {
              product.doSomething("FatFeet");
              return this;
       }

       @Override
       public Product GetResult() {
              return product;
       }

}

class ThinBuilder implements Builder {

       private Product product = new Product();

       @Override
       public Builder BuildHead() {
              product.doSomething("ThinHead+");
              return this;
       }

       @Override
       public Builder BuildBody() {
              product.doSomething("ThinBody+");
              return this;
       }

       @Override
       public Builder BuildHand() {
              product.doSomething("ThinHand+");
              return this;
       }

       @Override
       public Builder BuildFeet() {
              product.doSomething("ThinFeet");
              return this;
       }

       @Override
       public Product GetResult() {
              return product;
       }

}

// 具体使用类
class BuilderDesign {
       public static void main(String[]args) {
              // 注意调用逻辑
              Directordirector = new Director();

              FatBuilderfatBuilder = new FatBuilder();
              director.Construct(fatBuilder).display_result();

              ThinBuilderthinBuilder = new ThinBuilder();
              director.Construct(thinBuilder).display_result();
       }
}

六、原型模式（Prototype）：
类似于拷贝构造，有深拷贝和浅拷贝区别；主要实现方法是实现cloneable接口

abstract class ProtoType implements Cloneable{
    String a1;
    int a2;
    public abstract ProtoType clone();
}

class ProtoTypeA extends ProtoType {
    public ProtoTypeA(ProtoTypeA a) {
        this.a1 = a.a1;
        this.a2 = a.a2;
    }

    @Override
    public ProtoType clone() {
        return new ProtoTypeA(this);
    }
}