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.观察者模式