设计模式是一种在软件设计中经常使用的、经过验证的解决方案，可以帮助开发者解决在设计和实现软件时常见的问题。在众多设计模式中，创建模式（Creational Patterns）是一类特别关注对象创建的模式。这些模式可以简化对象的创建过程，提高代码的灵活性和可维护性。本文将介绍几种常见的创建模式：单例模式（Singleton）、工厂模式（Factory）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）和原型模式（Prototype）。
+-------------------+-------------------+-------------------+-------------------+-------------------+
| 模式 | 单例模式 | 工厂模式 | 抽象工厂模式 | 建造者模式 | 原型模式 |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 目的 | 确保一个类只有 | 提供创建对象的 | 提供创建一系列相 | 将复杂对象的构建 | 通过复制现有对象 |
| | 一个实例 | 接口 | 关或依赖对象的接 | 与表示分离 | 来创建新对象 |
| | | | 口 | | |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 使用场景 | 全局配置、日志记 | 创建对象的逻辑 | 创建多个产品族的 | 构建复杂的对象， | 创建成本较高的对 |
| | 录、数据库连接 | 分散在多个子类中 | 对象需要统一处理 | 且需要不同的表示 | 象，避免重复的初 |
| | | | | | 始化过程 |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 优点 | 确保单个实例， | 封装对象创建过 | 提高系统结构的可 | 灵活地构建复杂对 | 避免重复的初始化 |
| | 简化全局访问点 | 程，减少依赖 | 拓性和可维护性 | 象，提高代码的可 | 过程，提高性能 |
| | | | | 维护性和灵活性 | |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 缺点 | 单例模式可能导 | 工厂模式需要为 | 抽象工厂模式复杂 | 建造者模式可能导 | 原型模式需要实现 |
| | 致全局状态的 | 每个产品类型创 | 度较高，实施困难 | 致更多的类的创 | `clone` 方法，且 |
| | 管理问题 | 建具体的工厂类 | | 建 | 依赖于具体实现 |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在全局配置、日志记录、数据库连接等场景中非常有用。
代码示例
class Singleton:
_instance = None
@staticmethod
def get_instance():
if Singleton._instance is None:
Singleton._instance = Singleton()
return Singleton._instance
def __init__(self):
if Singleton._instance is not None:
raise Exception("This is a singleton class. Use get_instance() to get the single instance.")
self.value = None
# 使用单例模式
s1 = Singleton.get_instance()
s1.value = "Singleton Value"
s2 = Singleton.get_instance()
print(s2.value) # 输出: Singleton Value
2. 工厂模式（Factory）
工厂模式提供了一种创建对象的接口，但由子类决定实例化哪个类。工厂模式将对象的创建和使用分离，提高了代码的灵活性。
代码示例
from abc import ABC, abstractmethod
# 抽象产品类
class Product(ABC):
@abstractmethod
def operation(self):
pass
# 具体产品类
class ConcreteProductA(Product):
def operation(self):
return "ConcreteProductA"
class ConcreteProductB(Product):
def operation(self):
return "ConcreteProductB"
# 工厂类
class Factory:
def create_product(self, type):
if type == "A":
return ConcreteProductA()
elif type == "B":
return ConcreteProductB()
else:
raise ValueError("Invalid product type")
# 使用工厂模式
factory = Factory()
product_a = factory.create_product("A")
print(product_a.operation()) # 输出: ConcreteProductA
product_b = factory.create_product("B")
print(product_b.operation()) # 输出: ConcreteProductB
3. 抽象工厂模式（Abstract Factory）
抽象工厂模式提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。这种模式适用于多个产品族（Product Families）的场合。
代码示例
from abc import ABC, abstractmethod
# 抽象产品类
class AbstractProductA(ABC):
@abstractmethod
def operation_a(self):
pass
class AbstractProductB(ABC):
@abstractmethod
def operation_b(self):
pass
# 具体产品类
class ConcreteProductA1(AbstractProductA):
def operation_a(self):
return "ConcreteProductA1"
class ConcreteProductA2(AbstractProductA):
def operation_a(self):
return "ConcreteProductA2"
class ConcreteProductB1(AbstractProductB):
def operation_b(self):
return "ConcreteProductB1"
class ConcreteProductB2(AbstractProductB):
def operation_b(self):
return "ConcreteProductB2"
# 抽象工厂类
class AbstractFactory(ABC):
@abstractmethod
def create_product_a(self):
pass
@abstractmethod
def create_product_b(self):
pass
# 具体工厂类
class ConcreteFactory1(AbstractFactory):
def create_product_a(self):
return ConcreteProductA1()
def create_product_b(self):
return ConcreteProductB1()
class ConcreteFactory2(AbstractFactory):
def create_product_a(self):
return ConcreteProductA2()
def create_product_b(self):
return ConcreteProductB2()
# 使用抽象工厂模式
factory1 = ConcreteFactory1()
product_a1 = factory1.create_product_a()
product_b1 = factory1.create_product_b()
print(product_a1.operation_a()) # 输出: ConcreteProductA1
print(product_b1.operation_b()) # 输出: ConcreteProductB1
factory2 = ConcreteFactory2()
product_a2 = factory2.create_product_a()
product_b2 = factory2.create_product_b()
print(product_a2.operation_a()) # 输出: ConcreteProductA2
print(product_b2.operation_b()) # 输出: ConcreteProductB2
4. 建造者模式（Builder）
建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这种模式适用于构建复杂对象的场合。
代码示例
from abc import ABC, abstractmethod
# 复杂产品类
class Product:
def __init__(self):
self.parts = []
def add(self, part):
self.parts.append(part)
def show(self):
print("Product Parts:")
for part in self.parts:
print(part)
# 抽象建造者类
class Builder(ABC):
@abstractmethod
def build_part_a(self):
pass
@abstractmethod
def build_part_b(self):
pass
@abstractmethod
def get_result(self):
pass
# 具体建造者类
class ConcreteBuilder1(Builder):
def __init__(self):
self.product = Product()
def build_part_a(self):
self.product.add("Part A1")
def build_part_b(self):
self.product.add("Part B1")
def get_result(self):
return self.product
class ConcreteBuilder2(Builder):
def __init__(self):
self.product = Product()
def build_part_a(self):
self.product.add("Part A2")
def build_part_b(self):
self.product.add("Part B2")
def get_result(self):
return self.product
# 导演类
class Director:
def build(self, builder):
builder.build_part_a()
builder.build_part_b()
# 使用建造者模式
director = Director()
builder1 = ConcreteBuilder1()
builder2 = ConcreteBuilder2()
director.build(builder1)
product1 = builder1.get_result()
product1.show()
# 输出:
# Product Parts:
# Part A1
# Part B1
director.build(builder2)
product2 = builder2.get_result()
product2.show()
# 输出:
# Product Parts:
# Part A2
# Part B2
5. 原型模式（Prototype）
原型模式通过复制一个现有对象来创建新对象，而不是通过调用构造函数。这种模式适用于创建成本较高的对象，并且希望避免重复的初始化过程。
代码示例
import copy
# 原型类
class Prototype:
def clone(self):
pass
# 具体原型类
class ConcretePrototype1(Prototype):
def __init__(self, name):
self.name = name
def clone(self):
return copy.deepcopy(self)
def __str__(self):
return f"ConcretePrototype1: {self.name}"
class ConcretePrototype2(Prototype):
def __init__(self, name):
self.name = name
def clone(self):
return copy.deepcopy(self)
def __str__(self):
return f"ConcretePrototype2: {self.name}"
# 使用原型模式
prototype1 = ConcretePrototype1("Prototype1")
new_prototype1 = prototype1.clone()
print(new_prototype1) # 输出: ConcretePrototype1: Prototype1
prototype2 = ConcretePrototype2("Prototype2")
new_prototype2 = prototype2.clone()
print(new_prototype2) # 输出: ConcretePrototype2: Prototype2
总结
创建模式是设计模式中的一种重要类型，它们关注对象的创建过程，提供了一种更灵活、可维护的方式来创建对象。通过使用单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式，我们可以有效地解决在对象创建过程中遇到的多种问题，提高代码的质量和可扩展性。
- 单例模式：确保一个类只有一个实例，并提供一个全局访问点。
- 工厂模式：提供创建对象的接口，由子类决定实例化哪个类。
- 抽象工厂模式：提供创建一系列相关或依赖对象的接口，无需指定具体类。
- 建造者模式：将复杂对象的构建与表示分离，使同样的构建过程可以创建不同的表示。
- 原型模式：通过复制现有对象来创建新对象，避免重复的初始化过程。
