开发模式：

1、单例模式
单例模式的优点
1.在内存中只有一个实例，减少内存开支
2.只生产一个实例，减少系统性能的性能开销
3.避免对资源的多重占用。
4.可以在系统设置全局的访问点，优化和共享资源访问。（例如可以设置一个单例类，负责所有数据表的映射处理）

单例的缺点;
1.单例一般没有接口，扩展很困难。
2.单例如果持有Context对象，很容易引起内存泄漏，最好传递全局的Application Context。

饿汉式
优点：简单，线程安全
缺点：实例对象是static的，在声明的时候就实例化了，浪费资源

public class SingleTon {
    //将构造函数私有化
    private SingleTon() {
    }
 
    //创建私有实例对象
    private static final SingleTon singleTonInstance = new SingleTon();
 
    //对外提供方法，返回实例对象
    public static SingleTon getInstance() {
        return singleTonInstance;
    }
}

懒汉式
优点：用到的时候才会去实例化，在一定程度上节约了资源。
缺点：getInstance方法是用synchronized修饰的，该方法是同步的，为了保证线程安全，但是导致每次调用该方法的时候都会被同步，这样会消耗不必要的资源（不必要的同步开销，不建议使用）

public class SingleTon {
    //声明私有化
    private static SingleTon singleTonInstance;
    //将构造函数私有化
    private SingleTon() {
    }
    //懒汉式
    private static synchronized SingleTon getInstance(){
        if (null==singleTonInstance){
            singleTonInstance = new SingleTon();
        }
        return singleTonInstance;
    }
}

Double Check Lock双重检查锁定
优点：第一次执行getInstance方法时才会实例化，资源利用率高，效率高。
缺点：偶尔失效（高并发条件下，由于JDK版本问题，在jdk1.5之前会失败）

public class SingleTon {
    //声明私有化
    private static SingleTon singleTonInstance;
    //将构造函数私有化
    private SingleTon() {
    }
    //Double Check Lock
    public static SingleTon getInstance(){
        if (singleTonInstance==null){
            synchronized (SingleTon.class){
                if (singleTonInstance==null){
                    singleTonInstance = new SingleTon();
                }
            }
        }
        return singleTonInstance;
    }
}

内部类实现
第一次调用getInstance()方法的时候，虚拟机才会加载SingleTonHoulder静态内部类
优点：线程安全，保证单例的唯一性，延迟了对象的实例化，是推荐的方式。

public class SingleTon {
    //将构造函数私有化
    private SingleTon() {
    }
 
    public static SingleTon getInstance() {
        return SingleTonHoulder.singleTonInstance;
    }
 
    //静态内部类
    public static class SingleTonHoulder {
        private static final SingleTon singleTonInstance = new SingleTon();
    }
}

2、工厂模式（简单工厂模型，工厂方法模型，抽象工厂模型）
简单工厂模式：先创建工厂接口，接着实现接口（实现不同的产品具体操作），最后建厂生产产品（new的方式生产）

工厂方法模式：建厂需要抽象个工厂出来，然后工厂的实现，通过泛型反射的方法了实例化产品，代码如下：

抽象工厂：
public abstract class Factory {

    /**
     * @param clz 产品对象类型
     * @return 具体的产品类型
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);
}
具体工厂：
public class ConcreteFactory extends Factory {

    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product p = null;
        try {
            p = (Product) Class.forName(clz.getName()).newInstance();

        }catch (Exception e) {
            e.printStackTrace();
        }

        return (T) p;
    }
}

抽象工厂模式
抽象的工厂为每个产品创建对应的抽象的生成方法，然后的具体工厂中实现抽象的生成方法，生成方法通过new创建具体产品返回

abstract class AbsFactory{
        public abstract AbsProductA createProduct1();
        public abstract AbsProdcutB createProduct2();
}
class ConcreteFactory1 extends AbsFactory{
        private static ConcreteFactory instance = new ConcreteFactory();
        public ConcreteFactory getInstance(){
            return instance;
        }
        public AbsProductA createProductA(){
            return new ProductA1();
        }
        public AbsProdcutB createProductB(){
            return new ProductB1();
        }
    }

builder模式（对话框）：

public class NutritionFacts {
    private final int servingSize;//食品分量
    private final int servings;//食品
    private final int calories;//热量
    private final int fat;//脂肪
    private final int sodium;//钠
    private final int carbohydrate;//碳水化合物

    public static class Builder {
        //通过builder模式，给对象添加属性；
        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
   
        public Builder sodium(int sodium) {
            this.sodium = sodium;
            return this;
        }
        //返回外部对象
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }
    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

责任链模式（类似链表）：
1、先抽象处理者（节点）：
public abstract class Handler {
protected Handler successor;//指向下一个处理者
public abstract void handleRequest(String condition);（复杂版的不用字符串，用抽象接口或类来替代）
}
2、实例抽象处理者，生成处理链

23种开发模式