设计模式——创建型

1.单例模式

单例模式主要用于某个类有且只能用一个对象的场景，单例模式下不能外部实例化对象，由类内部自行私有化实例对象并提供一个可以获得该对象的方法。单例模式主要有饿汉模式（安全，但在编译时就会自动创建对象，即使不使用对象也会存在，会造成一定资源的浪费）、懒汉模式（安全，通过synchroized锁实现，每次获取对象时都会加锁，会对性能有一定影响）、DCL模式（基本安全，通过synchroized锁实现，在获取对象的方法内部加锁，当已经实例化对象时不会加锁直接返回对象，但在极少数情况下会出现线程不安全的情况）、静态内部类模式（安全，在类内定义一个静态的私有化的类来实例化对象）。

饿汉模式：
public class CEO {
    private static final mCEO = new CEO();//私有化实例化对象
    private CEO() { }//私有化构造方法
    public static CEO getCEO() {
        return mCEO;
    }//提供获取对象的接口
}
懒汉模式：
public class CEO {
    private static CEO mCEO;
    private CEO() { }
    public static synchroized CEO getCEO() {
        if(mCEO == null) {
            mCEO = new CEO(); 
        }
        return mCEO;
    }//synchroized，加同步锁，保证唯一；
}

DCL模式：
public class CEO {
    private static CEO mCEO = null;
    private CEO() { }
    public static CEO getCEO() {
        if(mCEO == null) {
            synchroized(CEO.class) {
                if(mCEO == null) {
                    mCEO = new CEO();
                }
            }
        }
        return mCEO;
    }
}

静态内部类模式：当外部类被加载时，静态内部类不会立即加载，
               只有在第一次调用内部类的静态成员或方法时才会加载，这样实现了懒加载的效果。
               同时，类加载过程是线程安全的，因此静态内部类单例模式也是线程安全的
public class CEO {
    private CEO() { }
    public static CEO getCEO() {
        return CEOInstance.mCEO;
    }
    //静态内部类
    private static class CEOInstance {
        private static final CEO mCEO = new CEO();
    }
}

2.构建者模式

用于创建复杂对象，将对象的创建与表示分离、按步奏创建对象，通常包含以下角色。

模式1：
产品（Product）——要创建的复杂对象，一般包含多种属性；
抽象构建者（Abstract Builder）——创建产品的各个抽象方法，以及返回最终产品的方法；
具体构建者（Concrete Builder）——负责产品的具体创建，以及最终产品的返回；
指导者（Director）——使用构建者构建产品；

public class Product {
	private String partA;
	private Int partB;
	private Double partC;
	public get();//相应参数的get方法
	public set();//相应参数的set方法
}
public interface Builder {
	void buildPartA(String part);
	void buildPartA(Int part);
	void buildPartA(Double part);
	Product getProduct();
}
public ConcreteBuilder implements Builder {
	private Product product;
	public ConcreteBuilder() {
		product = new Product();
	}
	@Override
	public  void buildPartA(String part) {
		product.setPartA(part);
	}
	@Override
	public  void buildPartA(Int part) {
		product.setPartB(part);
	}
	@Override
	public  void buildPartA(Double part) {
		product.setPartC(part);
	}
	@Override
	public  Product getProduct() {
		return product;
	}
}
public class Director {
	private Builder builder;
	public void setBuilder(Builder builder) {
		this.builder = builder;
	}
	public Product concreteProduct() {
		builder.builderPartA("partA");
		builder.builderPartB(45);
		builder.builderPartC(1.44);
		return builder.getProduct();
	}
}
//实际使用
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director();
director.setBuilder(builder);
Product product = director.concreteProduct();

模式2：

public class Product {
	private String A,B;
	class Builder {
		private Product product; 
		private String A,B;
		public Builder  setA(A) {
			this.A = A;
			return this;
		}
		public Builder  setB(B) {
			this.B = B;
			return this;
		}
		public Product build() {
			product = new Product();
			product.A = A;
			product.B = B;
			return product;
		}
	}
}

Product product =  Product.Builder().setA(A).setB(B).build();

3.工厂模式

特点：向上转换思想；不直接new对象，子类具体决定实例化什么对象；
应用：需要生成复杂对象的地方；
角色：抽象工厂、具体工厂、抽象产品、具体产品；
通用模式写法：
抽象工厂——定义一个返回抽象产品的抽象方法，该方法负责构造产品；
具体工厂——重写构造产品的方法，返回对象为具体产品；
抽象产品——定义一个抽象方法，该方法与产品关联；
具体产品——根据具体产品重写父类中与产品关联的抽象方法；

//抽象产品
public abstract class Product{
    public abstract void fuction();
}
//具体产品A
public class ProductA extends Product{
    @Override 
    public void function() {
        system.out.println("产品A的功能是...")；
    }
}
//具体产品B
public class ProductB extends Product{
    @Override 
    public void function() {
        system.out.println("产品B的功能是...")；
    }
}

//抽象工厂写法
public abstract class Factory{
    public abstract  Product  createProduct();
}
//具体工厂写法
public ConcreteFactoryA extends Factory {
    @Override
    public ProductA createProduct() {
        return new ProductA();
    }
}
public ConcreteFactoryB extends Factory {
    @Override
    public ProductB createProduct() {
        return new ProductB();
    }
}
//客户or测试
public class Client{
    public static void main(String[] args) {
        Factory factory = new ConcerateFactoryA();   
        Product product = factory.createProduct();
        product.fuction();
    }
}

4.原型模式

通过一个对象去创建（克隆）另一个与自己具有相同属性的对象，需要继承Cloneable接口重写clone方法。
注意：
1.克隆时不会调用构造函数，因此一些成员变量的初始化不能放在构造函数里
2.原型模式要注意深拷贝和浅拷贝的问题

public Prototype implents Cloneable {
    private String mStr;//浅拷贝
    private ArrayList<String> mStrs = new ArrayList<String>();//深拷贝
    @Override
    public Prototype clone() {
        try{
            Prototytpe obj = (Prototype)super.clone();
            obj.mStr = this.mStr;//obj.mStrs = this.mStrs;//此处为浅拷贝
            obj.mStrs = (ArrayList<String>)this.mStrs.clone();//此处为深拷贝
            return obj;
        } catch(Exception e) {
			...
        }
        return null;
    }
    public void setMstr(String str) {
        mStr = str;
    }
    public void setMstrs(ArrayList<String> strs) {
        mStrs = strs;
    }
    ...//该类的其他方法
}
public class Test{
    public static void main(String[] args) {
        Prototype prototype = new Prototype();
        Prototype clonePrototype = prototype.clone()//此处为初始化String 和 ArrayList<String> ，会使用默认值
    }
}