创建型模式共5种，单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
单例模式
定义：确保某一个类的实例只有一个，而且向其他类提供这个实例。
单例模式的使用场景：某个类的创建需要消耗大量资源，new一个对象代价太大，如访问IO和数据库等资源，或者避免多次创建该对象消耗内存过多。
懒汉模式
public class Singleton{
private static Singleton instance;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}懒汉模式是当需要改单例对象时，才初始化，与之相对的是饿汉模式，静态变量instance声明时就初始化。
由于每一次调用getInstance()都需要同步，资源消耗大。
double check Lock
public class Singleton{
private static Singleton instance;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null){
synchronize(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}在需要时才初始化，线程安全，且对象初始化后不再进行同步锁。
第一次判断null为了不必要的同步，第二层判空是在没有其他线程进入同步块时，是否需要创建实例。但上述示例代码还是有问题，在代码instance = new Singleton()处， 代码会编译成多条指令，大致做了3件事：
1.给Singleton的实例分配内存
2.调用Singleton()构造函数，初始化成员字段
3.强instance对象指向分配的内存空间（此时instance不为null)由于java编译器的指令执行在不影响结果的情况下是可以乱序的，所以无法保证上述2、3步骤是顺序执行的，这样当一个线程A获取单例时，先执行步骤3，步骤2还没有执行，就切换到线程B，由于此时instance已经不为空，所以线程B之间获得instance，但instance的初始化还没有完成，这样就会造成问题。
解决DCL的失效问题就是在字段instance前面加入关键字volatile，该关键字禁止指令重排序优化，确保执行到instance = new Singleton()时的指令顺序按照上述步骤1-2-3执行。
public class Singleton{
private volatile static Singleton instance;
private Singleton(){}
public static Singleton getInstance(){
if(instance == null){
synchronize(Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}静态内部类单例模式
public class Singleton(){
private Singleton(){}
public static Singleton(){
return InnerSingleton.instance;
}
//静态内部类
private static class InnerSingleton{
private static final Singleton instance = new Singleton();
}
}第一次加载Singleton时不会初始化instance，只有调用getInstance()时才初始化，因为此时需要加载静态内部类InnerSingleton。
这种方式不仅确保线程安全，也能够保证单例对象的唯一性，同时也延迟了对象实例化。
Android中的单例模式
通过context获取的各种系统服务，和LayoutInflate都是采用单例模式
WindowManager wm = (WindowManager) getSystemServie(getApplication().WINDOW_SERVICE);
//ListView中getView中使用LayoutInflate
itemView = LayoutInflate.from(context).inflate(id,null);Builder 创建者模式
定义：讲一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
就是说某一个对象有许多字段参数需要设置，不同的设置得到不同的结果。
public class Config{
private int size;
private int number;
private String name;
public Config（int size, int number, String name){
this.size = size;
this.number = number;
this.name = name;
}
public void setSize(int size){
this.size = size;
}
public void setNumber(int number){
this.number = number;
}
public void setName(String name){
this.name = name;
}
}如果只是极少数的变量需要设置，通过构造器还是可以接受的，如果变量个数特别多，构造器参数对应哪个变量就变得很难读懂，当只需要部分参数时，由需要重新写一个构造方法，这是很不利于程序扩展的。
public class Config{
private int size;
private int number;
private String name;
public int getSize() {
return size;
}
public int getNumber() {
return number;
}
public String getName() {
return name;
}
public static class Builder{
private int size;
private int number;
private String name;
public Builder setSize(int size){
this.size = size;
return this;
}
public Builder setNumber(int number){
this.number = number;
return this;
}
public Builder setName(String name){
this.name = name;
return this;
}
public Config build(){
Config config = new Config();
config.size = size;
config.number = number;
config.name = name;
return config;
}
}
}当我们需要初始化Config时，通过它的静态内部类Builder进行实例化
Config.Builder builder = new Config.Builder();
Config config = builder.setName("haha")
.setNumber(2)
.setSize(3)
.build();通过返回this实现链式调用，代码可读性强，也更好维护。
Android中的Builder模式
我们常用的提示框就采用了Builder模式
AlertDialog.Builer builder=new AlertDialog.Builder(context);
builder.setIcon(R.drawable.icon)
.setTitle("title")
.setMessage("message")
.setPositiveButton("Button1",
new DialogInterface.OnclickListener(){
public void onClick(DialogInterface dialog,int whichButton){
setTitle("click");
}
})
.create()
.show();Notification从API11开始也采用了Builder模式
Notification.Builder builder = new Notification.Builder(this);
Intent intent = new Intent(this, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
builder.setContentIntent(pendingIntent)
.setSmallIcon(R.drawable.ic_launcher)
.setWhen(System.currentTimeMillis())
.setContentText("内容")
.setContentTitle("标题")
.setTicker("状态栏上显示...")
.setNumber(2)
.setOngoing(true);
//API11
Notification notification = builder.getNotification();
//API16
Notification notification = builder.build();原型模式
定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
原型模式就是将一个对象进行克隆，将一个对象的内部属性完全复制，生成一个新的拷贝对象，被复制的实例对象就称为原型。当一个对象的属性过多时，重新new一个对象比较复杂和消耗资源，此时就可以用原型模式。
public class CloneMode implements Cloneable {
public String txt;
public CloneMode(String txt) {
this.txt = txt;
System.out.println("----CloneMode构造函数----");
}
public CloneMode clone() {
CloneMode cm;
try {
cm = (CloneMode) super.clone();
cm.txt = this.txt;
return cm;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}注意通过clone拷贝对象时并不会执行构造函数。还要注意的就是深拷贝和浅拷贝，浅拷贝指的是拷贝原型对象时，并没有将原型对象的字段重新构造，而是将拷贝后的副本中的字段引用指向原型对象中的字段。举个例子：A引用B，这两个对象指向同一个地址，当修改A时，B也会改变，B修改时，A也会改变。深拷贝则对于原型对象中的引用类型字段也进行拷贝，生成一个新的引用对象。将上述代码添加一个引用类型对象，深拷贝如下：
public class CloneMode implements Cloneable {
public int num;
//引用类型对象
public ArrayList<String> lists = new ArrayList<>();
public CloneMode(int num) {
this.num = num;
System.out.println("----CloneMode构造函数----");
}
public CloneMode clone() {
CloneMode cm;
try {
cm = (CloneMode) super.clone();
cm.num = this.num;
//深拷贝：引用类型对象也进行拷贝；
cm.lists = (ArrayList<String>)this.lists.clone();
//浅拷贝
//cm.lists = this.lists;
return cm;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}Android中的原型模式
Uri uri=Uri.parse("smsto:10086");
Intent shareIntent=new Intent(Intent.ACTION_SENDTO,uri);
//克隆副本
Intent intent=(Intetn)shareIntent.clone();
startActivity(intent);工厂模式
定义:工厂模式定义一个用于创建对象的接口，让子类决定实例化哪个类。
下述代码为工厂模式的通用代码
public abstract class Product{
public abstract void method();
}
public class ConcreteProductA extends Prodect{
public void method(){
System.out.println("我是产品A!");
}
}
public class ConcreteProductB extends Prodect{
public void method(){
System.out.println("我是产品B!");
}
}
public abstract class Factory{
public abstract Product createProduct();
}
public class MyFactory extends Factory{
public Product createProduct(){
return new ConcreteProductA();
}
}Android中的工厂模式
其实，在getSystemService方法中就是用到了工厂模式，他就是根据传入的参数决定创建哪个对象，当然了，由于返回的都是以单例模式存在的对象，因此不用new，直接把单例返回就好。
public Object getSystemService(String name) {
if (getBaseContext() == null) {
throw new IllegalStateException("System services not available to Activities before onCreate()");
}
//........
if (WINDOW_SERVICE.equals(name)) {
return mWindowManager;
} else if (SEARCH_SERVICE.equals(name)) {
ensureSearchManager();
return mSearchManager;
}
//.......
return super.getSystemService(name);
}抽象工厂模式
定义：为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们的具体类。
模式通用代码：
public abstract class AbstractProductA{
public abstract void method();
}
public abstract class AbstractProdectB{
public abstract void method();
}
public class ConcreteProductA1 extends AbstractProductA{
public void method(){
System.out.println("具体产品A1的方法！");
}
}
public class ConcreteProductA2 extends AbstractProductA{
public void method(){
System.out.println("具体产品A2的方法！");
}
}
public class ConcreteProductB1 extends AbstractProductB{
public void method(){
System.out.println("具体产品B1的方法！");
}
}
public class ConcreteProductB2 extends AbstractProductB{
public void method(){
System.out.println("具体产品B2的方法！");
}
}
public abstract class AbstractFactory{
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory{
public AbstractProductA createProductA(){
return new ConcreteProductA1();
}
public AbstractProductB createProductB(){
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 extends AbstractFactory{
public AbstractProductA createProductA(){
return new ConcreteProductA2();
}
public AbstractProductB createProductB(){
return new ConcreteProductB2();
}
}Android中的抽象工厂模式
从Framework角度来看，Activity和Service都可以看做是一个具体的工厂，oncreate()和onBind()就相当于一个工厂方法。