设计模式1：创建型模式

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

前言

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

1 单例模式（Singleton）

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

public class President {
	private static President instance; // 唯一
	private President() {} // 禁止外部new
	public 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); 

适用场景：资源密集型对象（如数据库连接、网络套接字、游戏中的粒子系统）的高效复用。
优点：减少对象创建和销毁的开销；提高系统性能。
缺点：增加系统复杂度；管理池对象需要额外资源。