3、创建型模式---单例模式&原型模式&建造者模式

1、单例模式【Singleton Pattern】
     几乎所有面向对象的程序中，总有一些类的对象需要是唯一的，例如，通过数据库句柄到数据库的连接是独占的。您希望在应用程序中共享数据库句柄，因为在保持连接打开或关闭时，它是一种开销。
    怎样确保一个特殊类的实例是独一无二的（它是这个类的唯一实例），并且这个实例易于被访问呢？
解决方案
1）全局变量：一个全局变量使得一个对象可以被访问，但它不能防止你实例化多个对象。因为你的任何代码都能修改全局变量，这将不可避免的引起更多调试的意外。换句话说，全局变量的状态总是会出现一些问题的。
2）类构造函数私有和类自身的静态方法：让类自身负责保存它的唯一实例(静态变量)。这个类可以保证没有其他实例可以被创建（通过截取创建新对象的请求） ，并且它可以提供一个访问该实例的方法（静态方法）。这就是Singleton模式。
public class Emperor {
private static Emperor emperor = null;
private Emperor(){
//封装构造方法
}
public static Emperor getInstance(){
if(emperor == null){
emperor = new Emperor();
}
return emperor;
}
}
在一个B/S 项目中， 假如现在有两个线程A 和线程B，线程A 执行到 this.singletonPattern = new SingletonPattern()，正在申请内存分配，可能需要0.001 微秒，就在这0.001 微秒之内，线程B 执行到if(this.singletonPattern == null)，你说这个时候这个判断条件是true 还是false？是true，那
然后呢？线程B 也往下走，于是乎就在内存中就有两个SingletonPattern 的实例了，是不是出问题了。
简单的解决方法：
public class SingletonPattern {
private static final SingletonPattern singletonPattern= new SingletonPattern();
//限制不能由其他直接产生一个实例
private SingletonPattern(){
}
public synchronized static SingletonPattern getInstance(){
return singletonPattern;
}
}

2、原型模式

不通过 new 关键字来产生一个对象，而是通过对象拷贝来实现的模式就叫做原型模式.

应用：线程不安全；
对象拷贝时，类的构造函数是不会被执行的。
public class Prototype implements Cloneable {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public Prototype(String name) {
        setName(name);
    }

    public Object clone(){
        try {
            return super.clone();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Prototype pro = new Prototype("prototype");
        Prototype pro2 = (Prototype)pro.clone();
        System.out.println(pro.getName());
        System.out.println(pro2.getName());
    }
}
    原型模式适合在什么场景使用？一是类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等；二是通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；三是一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。


3、建造者模式
  

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

Builder类：是为创建一个product对象的各个部件指定的抽象接口
ConcreteBuilder类：他是具体建造者，实现Builder接口，构造和装配各个部件
Director类：他是构建一个使用Builder接口的对象

public interface PersonBuilder {
    void buildHead();
    void buildBody();
    void buildFoot();
    Person buildPerson();
}

public class ManBuilder implements PersonBuilder {

    Person person;
    public ManBuilder() {
        person = new Man();
    }   
    public void buildBody() {
        person.setBody("建造男人的身体");
    }
    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }
    public void buildHead() {
        person.setHead("建造男人的头");
    }
    public Person buildPerson() {
        return person;
    }
}

public class PersonDirector {
    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }