设计模式1：创建型模式
设计模式2：结构型模式（编写中）
设计模式3：行为型模式（编写中）

前言

设计模式是软件开发中经过验证的可复用解决方案，它们源自实践、提炼于经验，并在面向对象编程中扮演着关键角色。GoF（Gang of Four）设计模式分为创建型、结构型和行为型三大类，共23种。设计模式的核心价值在于提高代码的可维护性、可扩展性和可复用性，同时遵循软件设计原则。
本文介绍创建型模式。创建型模式关注对象的创建过程，通过将对象的创建与使用分离，使系统能够灵活地控制对象的生成方式。

1 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。它适用于需要严格控制实例数量的场景，如全局配置、数据库连接池和日志系统等。
核心思想：通过私有构造函数限制外部实例化，使用静态变量保存唯一实例，并通过静态方法提供全局访问。
Java实现：

public class President {private static President instance; // 唯一private President() {} // 禁止外部newpublic static President getInstance() { if (instance == null) {  instance = new President(); // 延迟初始化  }  return instance; } 
}// 使用示例 
President p1 = President.getInstance(); 
President p2 = President.getInstance(); 
System.out.println(p1 == p2); // true（同一个）

适用场景：需要全局唯一访问点的场景，如配置管理、资源共享等。
优点：节省内存，避免重复创建；提供全局访问点。
缺点：多线程环境下需加锁（可用双重检查锁优化）；破坏了单一职责原则。

2 工厂方法模式（Factory Method）

工厂方法模式定义一个创建对象的接口，但由子类决定实例化哪一个类，将实例化延迟到子类。它适用于需要解耦对象创建与使用，同时允许扩展的场景。
核心思想：通过抽象工厂类定义创建对象的方法，具体实现由子类完成，遵循开闭原则。
Java实现：

// 抽象产品类 
interface Transport {  void deliver(); 
}
// 具体产品类 
class Truck implements Transport {  public void deliver() {  System.out.println(“陆运”);  } 
}
class Ship implements Transport {  public void deliver() {  System.out.println(“海运”);  } 
}
// 抽象工厂类 
interface Logistics {  Transport createTransport(); 
}
// 具体工厂类 
class RoadLogistics implements Logistics {  public Transport createTransport() {  return new Truck();  } 
}
class SeaLogistics implements Logistics {  public Transport createTransport() {  return new Ship();  }
}// 使用示例 
Logistics roadLogistics = new RoadLogistics(); 
Transport truck = roadLogistics.createTransport(); 
truck.deliver();

适用场景：对象创建逻辑复杂（如依赖配置、外部服务），需解耦对象创建与使用。
优点：扩展性强，新增产品只需添加子类；遵循开闭原则。
缺点：每新增一个产品就要新增一个工厂类；类层次结构可能变得复杂。

3 抽象工厂模式（Abstract Factory）

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。它适用于需要创建多个相关对象家族的场景。
核心思想：通过工厂接口定义一组产品对象的创建方法，具体实现由子类完成，实现产品家族的统一创建。
Java实现：

// 产品接口 
interface Phone {  void call(); 
}
interface Earphone {  void play(); 
}
// 苹果产品家族 
class iPhone implements Phone {  public void call() {  System.out.println(“iPhone通话”);  } 
}
class AirPods implements Earphone {  public void play() {  System.out.println(“AirPods播放”);  } 
}
// 小米产品家族 
class MiPhone implements Phone {  public void call() {  System.out.println(“小米手机通话”);  } 
}
class MiEarphone implements Earphone {  public void play() {  System.out.println(“小米耳机播放”);  } 
}
// 抽象工厂接口 
interface TechFactory {  Phone createPhone();  Earphone createEarphone(); 
}
// 具体工厂类 
class AppleFactory implements TechFactory {  public Phone createPhone() {  return new iPhone();  }public Earphone createEarphone() {  return new AirPods();  } 
}
class MiFactory implements TechFactory {  public Phone createPhone() {  return new MiPhone();  }public Earphone createEarphone() {  return new MiEarphone();  } 
}// 使用示例 
TechFactory factory = new AppleFactory(); 
Phone phone = factory.createPhone(); 
Earphone earphone = factory.createEarphone();
phone.call(); // iPhone通话 
earphone.play(); // AirPods播放

适用场景：跨平台应用（如Windows/macOS按钮）、产品线扩展等。
优点：产品族统一创建，保证一致性；扩展性强，新增产品族只需添加子类。
缺点：工厂类数量随产品族增加而增加；难以支持产品族的动态切换。

4 建造者模式（Builder）

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。它适用于需要构建复杂对象，且对象的构建过程可能变化的场景。
核心思想：通过建造者类逐步构建对象，最后通过build方法返回完整对象；使用导演类控制构建过程。
Java实现：

// 奶茶产品类 
class BubbleTea {  private String size;  private boolean ice;  private List toppings;// 私有构造函数  private BubbleTea(Builder builder) {  this.size = builder.size;  this.ice = builder.ice;  this.toppings = builder.toppings;  }// 获取建造者  public static class Builder {  private String size = “中杯”;  private boolean ice = true;  private List toppings = new ArrayList<>();public Builder size(String size) {  this.size = size;  return this;  }public Builder ice(boolean ice) {  this.ice = ice;  return this;  }public Builder addTopping(Topping topping) {  toppings.add(topping);  return this;  }public BubbleTea build() {  return new BubbleTea(this);  }  }// 配料枚举  enum Topping {  波霸, 珍珠, 椰果, 西米  } 
}// 使用示例 
BubbleTea bubbleTea = new BubbleTea.Builder()  .size(“大杯”)  .ice(false)  .addTopping(BubbleTea.Topping.波霸)  .addTopping(BubbleTea.Topping.珍珠)  .build();
System.out.println(“奶茶规格：” + bubbleTea.size); 
System.out.println(“是否加冰：” + (bubbleTea.ice ? “是” : “否”)); 
System.out.println(“配料：” + bubbleTea.toppings);

适用场景：构建复杂对象（如订单、配置文件）、参数较多的构造函数等。
优点：参数解耦，构建过程清晰；支持部分构建和链式调用。
缺点：类数量增加；过度使用可能增加代码复杂度。

5 原型模式（Prototype）

原型模式通过复制现有对象来创建新对象，避免重复初始化。它适用于对象创建成本高，或需要快速复制已有对象的场景。
核心思想：通过克隆方法复制对象，创建新实例；使用深拷贝或浅拷贝控制复制深度。
Java实现：

// 原型接口 
interface Shape extends Cloneable {  void draw();  Shape clone(); 
}
// 具体形状类 
class Circle implements Shape {  private String color;public Circle(String color) {  this.color = color;  }public void draw() {  System.out.println(“绘制圆形，颜色：” + color);  }@Override  public Shape clone() {  try {  return (Shape) super.clone();  } catch (CloneException e) {  throw new RuntimeException(e);  }  } 
}
class Square implements Shape {  private int sideLength;public Square(int sideLength) {  this.sideLength = sideLength;  }public void draw() {  System.out.println(“绘制正方形，边长：” + sideLength);  }@Override  public Shape clone() {  try {  return (Shape) super.clone();  } catch (CloneException e) {  throw new RuntimeException(e);  }  } 
}// 使用示例 
Circle circle = new Circle(“红色”); 
Shape circleClone = circle.clone();
circleClone.draw(); // 绘制圆形，颜色：红色

适用场景：对象创建成本高（如数据库连接、图形对象）、需要快速复制已有对象等 [3]。
优点：性能高效，避免重复初始化；代码简洁，直接使用克隆方法 [3]。
缺点：深拷贝实现复杂；不适合不可克隆的对象。

6 对象池模式（Object Pool）

对象池模式是单例模式的扩展，通过预先创建并管理对象集合，减少频繁创建/销毁的开销。它适用于资源密集型对象（如数据库连接、网络套接字）的高效复用场景。
核心思想：通过对象池管理对象的生命周期，包括对象的分配、重用和释放；使用工厂模式创建和销毁对象。
Java实现：

// 池化对象接口 
interface PoolableObject {  void activate(); // 激活对象  void passivate(); // 使对象空闲 
}
// 对象池接口 
interface ObjectPool {     T borrowObject();  // 获取对象     void returnObject(T obj);  // 归还对象     void clear();      // 清除池中对象 
}
// 对象池工厂接口 
interface PoolableObjectFactory {     T makeObject();     // 创建对象     void destroyObject(T obj);  // 销毁对象     void activateObject(T obj);  // 激活对象     void passivateObject(T obj);  // 使对象空闲 
}
// 具体实现 
class SimpleObjectPool implements ObjectPool {private final PoolableObjectFactory factory;     private final List pool = new ArrayList<>();     private final int maxPoolSize;public SimpleObjectPool(PoolableObjectFactory factory, int maxPoolSize) {         this.factory = factory;         this.maxPoolSize = maxPoolSize;         // 初始化池         for (int i = 0; i < maxPoolSize; i++) {             T obj = factory.makeObject();             obj.passivate();             pool.add(obj);        }     }@Override  public T borrowObject() {  // 获取空闲对象  for (T obj : pool) {  if (!obj.isActive()) {  obj.activate();  return obj;  }}  // 如果池已满，可能需要创建新对象  if (pool.size() < maxPoolSize) {  T obj = factory.makeObject();  obj.activate();  pool.add(obj);  return obj;  }  // 池已满，无法获取对象  return null;  }@Override  public void returnObject(T obj) {  if (pool.contains(obj)) {  obj.passivate();  } else {  // 可能需要处理不属于池的对象  factory.destroyObject(obj);  }  }@Override  public void clear() {  for (T obj : pool) {  factory.destroyObject(obj);  }  pool.clear();  } 
}
// 使用示例 
// 定义池化对象 
class DatabaseConnection implements PoolableObject {  private boolean active = false;public void activate() {  this.active = true;  System.out.println(“连接激活”);  }public void passivate() {  this.active = false;  System.out.println(“连接空闲”);  }public boolean.isActive() {  return active;  }public void connect() {  System.out.println(“建立数据库连接”);  }public void disconnect() {  System.out.println(“关闭数据库连接”);  } 
}
// 定义工厂 
class DatabaseConnectionFactory implements PoolableObjectFactory {     @Override     public DatabaseConnection makeObject() {         return new DatabaseConnection();     }@Override  public void destroyObject(DatabaseConnection obj) {  obj.disconnect();  }@Override  public void activateObject(DatabaseConnection obj) {  obj.activate();  }@Override  public void passivateObject(DatabaseConnection obj) {  obj.passivate();  } 
}
// 使用对象池 
ObjectPool pool = new SimpleObjectPool<>(new DatabaseConnectionFactory(), 10);
DatabaseConnection conn = pool borrowObject(); 
// 使用连接 
conn.connect(); 
// 归还连接 
pool.returnObject(conn);