设计模式-创建型 学习笔记

创建型

工厂方法模式

一个商店发放几种不同的物品，如优惠卷，消费卡，实物商品等，每种物品都有自己内部实现的业务逻辑，在实际开发中通过判断type从而判断具体的实例类型会增加代码复杂度，难以维护和重构。可以对三种物品抽象出一个统一发放物品的接口，再有一个根据判断type返回相应的实现的工厂类。避免了创建者与具体的产品逻辑耦合，满足单一职责，每一个业务逻辑实现都在自己所属的类中完成，满足开闭原则，无需更改使用调用方就可以在程序中引入新的类型。

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种接口，用于创建一系列相关或依赖的对象，而无需指定它们的具体类。抽象工厂模式是工厂方法模式的扩展，它涉及多个工厂方法，每个工厂方法负责创建一组相关的产品。

抽象工厂模式的主要组成部分包括：

1. 抽象工厂（Abstract Factory）：定义了一组创建产品的抽象方法，每个方法通常对应一种产品，这些产品之间具有相关性。
2. 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建一组相关产品。每个具体工厂通常对应一个产品族。
3. 抽象产品（Abstract Product）：定义了产品的抽象接口，通常包括多个方法，用于描述产品的行为。
4. 具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为。

使用抽象工厂模式的主要优点包括：

• 它可以确保创建的产品之间是相互兼容的，因为每个具体工厂负责创建一整组相关产品。
• 客户端代码不需要知道具体产品的类名，因为它只与抽象工厂和抽象产品接口交互。
• 可以轻松扩展产品族，只需添加新的具体工厂和对应的具体产品

建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它用于构建一个复杂对象，并且使其构建过程更加灵活、清晰。通常，当一个对象有多个可配置参数时，建造者模式可以使你更容易地创建这个对象，而不必在构造函数中传递大量参数。

原型模式

原型模式（Prototype Pattern）是一种创建型设计模式，它用于创建对象的复制，而无需直接使用构造函数来创建新对象。原型模式通过复制现有对象来创建新对象，从而保持对象的状态和行为。这种方式使得可以创建新对象，而无需了解对象的具体构造过程。

原型模式的主要优点包括：

• 降低了创建对象的复杂性，因为不需要了解对象的内部构造，只需复制一个现有对象。
• 提供了一种更高效的方式来创建对象，特别是当对象的构建过程比较昂贵或复杂时。
• 允许动态添加或删除对象的属性，因为克隆操作可以复制整个对象的状态。

原型模式通常用于以下情况：

• 当创建对象的过程比较昂贵或复杂，且希望避免重复构建相似对象时，可以使用原型模式来复制现有对象。
• 当需要动态创建对象的变体时，原型模式允许在运行时添加或删除对象的属性。
• 当对象之间的差异在于它们的状态，而不是行为时，原型模式是一个合适的选择。

总之，原型模式通过克隆已有对象来创建新对象，以降低对象创建的复杂性，提高效率，并允许在运行时动态添加或删除对象的属性。

单例模式

饿汉式

在这种模式下，单例实例在类加载时就被创建，而不是在第一次使用时创建。这样可以确保在多线程环境下也只有一个实例。饿汉式单例的缺点是，如果该实例在应用程序中很少或从未被使用，将浪费一些内存。

懒汉式

在这种模式下，单例实例在第一次使用时被创建。这样可以延迟实例的创建，从而减少内存占用。但需要注意，在多线程环境下，需要考虑线程安全性。

线程安全的懒汉式单例的实现具体有以下几个：

• 双重检查锁单例（Double-Checked Locking Singleton）：这是一种优化的懒汉式单例实现，它通过双重检查锁来提高多线程环境下的性能。在这种模式下，首次检查是为了减少性能开销，第二次检查是确保只创建一个实例。以下是一个示例：

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

• 静态内部类单例（Static Inner Class Singleton）：这种方式结合了懒汉式和饿汉式的优点。在这种模式下，单例实例在类加载时不会被初始化，而是在第一次访问时通过静态内部类来创建。这种方式既延迟了实例的创建，又保证了线程安全。以下是一个示例：

  public class Singleton {
      private Singleton() {}
  
      private static class SingletonHolder {
          private static final Singleton instance = new Singleton();
      }
  
      public static Singleton getInstance() {
          return SingletonHolder.instance;
      }
  }
  

• 枚举单例（Enum Singleton）：这种方式是一种简洁且线程安全的实现单例模式的方式。枚举类型在Java中天生就是单例的，因此这是一种推荐的方式。

• CAS单例 CAS是一种乐观锁机制，它允许一个线程在写入共享变量之前先比较当前值，如果当前值仍然等于期望值，就会更新为新值；否则，操作失败。CAS的经典应用场景是在多线程环境下实现原子操作。

  public class Singleton2 {
      private static final AtomicReference<Singleton2> INSTANCE = new AtomicReference<>();
  
      private static Singleton2 singleton2;
  
      private Singleton2(){}
  
      public final static Singleton2 getInstance(){
          for (;;){
              Singleton2 singleton = INSTANCE.get();
              if (singleton != null) return singleton;
              INSTANCE.compareAndSet(null,new Singleton2());
              return INSTANCE.get();
          }
      }
  }