23种设计模式

单例模式

懒汉模式：延迟加载，只有在真正使用的时候，才开始实例化。

​ 1）本质上是利用类的加载机制来保证线程安全。

​ 2） 只有在实际使用的时候，才会触发类的初始化，所以也是懒加载的一种形式。

问题：

​ 1）线程安全问题。

​ 2）如果使用了double check 加锁，要优化。

​ 3）编译器（JIT），CPU有可能对指令进行重排序，导航使用到尚未初始化的实例，可以通过添加volatile关键字进行修饰，对于volatitle修饰的字段，可以防止指令重排。

//懒汉模式步骤。
	1）提供私有属性。
  2）提供私有构造函数，避免了从外部重复对应实例的创建。
  3）静态方法：提供全局的访问点。可以直接.调用。
class LazySingleton{
  //1）提供私有属性。
  //volatitle -> 防止字节码层指令重排。
  private volatitle static LazySingleton instance;
  
  //2）构造函数，避免了从外部重复对应实例的创建。
  private LazySingleton(){}
  
  //3）静态方法，提供全局唯一访问点。
  public static LazySingleton getInstance(){
    if(instance == null){
      // synchronized 加锁，解决线程安全问题。
      synchronized (LazySingleton.class){
        if(instance == null){
          instance = new lazySingleoton();
          // 1.分配空间
          // 2.初始化
          // 3.引用赋值
        }
      }
      return instance;
    }
  }
}

饿汉模式：

原理： 利用类加载机制，初始化阶段就完成了实例的初始化，本质上就是借助于jvm类加载机制，保证实例的唯一性。

类加载过程

1）加载二进制数据到内存中，生成对应的class数据结构。

2） 连接：a.验证 b.准备(给类的静态成员变量赋默认值) c.解析

3）初始化：给类的静态变量赋初值。

class HungrySingleTon{
  
  // 内部实例化，避免外部调用实例化。
  private static HungrySingleTon instatnce = new HungrySingleTon();
  
  // 构造方法，可以直接.调用。
  private HungrySingleTon(){}
  
  // 公用方法返回实例。
  public static HungrySingleTon getInstance(){
    retrn instatce;
  }
}

静态内部类模式

原理：

​ 1）本质上是利用类的加载机制来保证线程安全。

​ 2）只有在实际使用的时候，才会触发类的初始化，所以也是懒加载的一种形式。

class InnnerClassSingleton{
  
  // 内部实例化，避免外部调用实例化。
  private static InnnerClassSingleton instatnce = new InnnerClassSingleton();
  
  // 私有构造方法，可以直接.调用。
  private InnnerClassSingleton(){
    // 避免使用反射机制实例化多个单例出来。 饿汉模式和内部静态类模式单例可以用此方法来避免多个单例实例化。
    if(InnnerClassSingleton != null){
      thorw new RuntimeException("单例不允许多个实例")
    }
  }
  
  // 公用方法返回实例。
  public static InnnerClassSingleton getInstance(){
    retrn InnnerClassSingleton.instatnce;
  }
}

抽象工厂模式

意图： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

优点： 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点： 产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景：QQ 换皮肤，一整套一起换、生成不同操作系统的程序。

// 定义抽象类
interface IConnerction{
	viod connect();
}
// 定义抽象类
interface ICommand{
	viod commad();
}

// 定义一组抽象类，由一堆抽象类组成的就叫抽象工厂。
interface IDateBaseUtils{
	IConnerction getConnerction();
	ICommand getCommand();
}

//继承抽象类并实现抽象方法。
class MysqlConnection implements IConnerction{
	@override
	public void connect(){
		//抽象方法需要子类实现。
	}
}

建造者模式

ProductObject: 描述产品对象。

Director：构建builder接口的对象。隔离客户与对象的生产过程 ，负责控制产品对象的生产过程 。

Builder：建造者，声明了具体建造者的公共接口（产品的过程和反回方法）

ConcreteBuilder：具体建造者，实现Builder接口来创建具体产品。

产品具体描述-> ProductObject

定义抽象接口或方法 -> Director

继承工厂重构属性或方法 -> Builder

具体实现 -> ConcreteBuilder

具体调用-> call