设计模式

1.单例模式

 只有一个实例

实例自己造

对外所有提供这个实例

懒汗：懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例

 public static BusinssBase instance;
 public synchronized static BusinssBase getInstance() {
        if (instance == null) {
            instance = new BusinssBase();
        }
        return instance;
    }

    public BusinssBase() {
        this.mInstrumentation = Contacts.getInstance().getmInstrumentation();

双重检查锁定：锁前和锁后都添加

public static Singleton getInstance() {  
        if (singleton == null) {    
            synchronized (Singleton.class) {    
               if (singleton == null) {    
                  singleton = new Singleton();   
               }    
            }    
        }    
        return singleton;   
    }  

饿汗：

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

但是不管使用不使用，都会占用内存

public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态工厂方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}  

2.工厂模式

每个人都是小作坊，在生产的时候通过new小作坊带参数去生成物品。

后面合并成一个工厂了，统一去实例化工厂并带上参数去生成产品 --简单工厂

后面工厂大了，需要继续抽象，会生成各类型的产品。抽象成：工厂接口，工厂实现，产品接口，产品实现。。--工厂方法

简单工厂：把对象的创建放到一个工厂类中，通过参数来创建不同的对象。
这个缺点是每添一个对象，就需要对简单工厂进行修改（尽管不是删代码，仅仅是添一个switch case，但仍然违背了“不改代码”的原则）

工厂方法：每种产品由一种工厂来创建，一个工厂保存一个new。

4类：工厂接口，工厂实现，产品接口，产品实现

如果新增一个产品，则新增：工厂实现，产品接口，产品实现

3.外观模式

Facade模式定义了一个高层接口，所有访问下面子系统或功能的都通过这个类

4.代理模式

A,B继承C

A实现C

B继承A并用A的方法实现C，在A方法加上before和after

5.观察者模式