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 CEOInstance mCEO = new CEO();}
}

2.构建者模式

用于创建复杂对象，将对象的创建与表示分离、按步奏创建对象，通常包含以下角色。
产品（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();}@Overridepublic  void buildPartA(String part) {product.setPartA(part);}@Overridepublic  void buildPartA(Int part) {product.setPartB(part);}@Overridepublic  void buildPartA(Double part) {product.setPartC(part);}@Overridepublic  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();

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 {@Overridepublic ProductA createProduct() {return new ProductA();}
}
public ConcreteFactoryB extends Factory {@Overridepublic 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>();//深拷贝@Overridepublic 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> ，会使用默认值}
}