设计模式之创建模式篇
设计模式是一种在软件设计中经常使用的、经过验证的解决方案，可以帮助开发者解决在设计和实现软件时常见的问题。在众多设计模式中，创建模式（Creational Patterns）是一类特别关注对象创建的模式。这些模式可以简化对象的创建过程，提高代码的灵活性和可维护性。本文将介绍几种常见的创建模式：单例模式（Singleton）、工厂模式（Factory）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）和原型模式（Prototype）。
+-------------------+-------------------+-------------------+-------------------+-------------------+
| 模式 | 单例模式 | 工厂模式 | 抽象工厂模式 | 建造者模式 | 原型模式 |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 目的 | 确保一个类只有 | 提供创建对象的 | 提供创建一系列相 | 将复杂对象的构建 | 通过复制现有对象 |
| | 一个实例 | 接口 | 关或依赖对象的接 | 与表示分离 | 来创建新对象 |
| | | | 口 | | |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 使用场景 | 全局配置、日志记 | 创建对象的逻辑 | 创建多个产品族的 | 构建复杂的对象， | 创建成本较高的对 |
| | 录、数据库连接 | 分散在多个子类中 | 对象需要统一处理 | 且需要不同的表示 | 象，避免重复的初 |
| | | | | | 始化过程 |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 优点 | 确保单个实例， | 封装对象创建过 | 提高系统结构的可 | 灵活地构建复杂对 | 避免重复的初始化 |
| | 简化全局访问点 | 程，减少依赖 | 拓性和可维护性 | 象，提高代码的可 | 过程，提高性能 |
| | | | | 维护性和灵活性 | |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
| 缺点 | 单例模式可能导 | 工厂模式需要为 | 抽象工厂模式复杂 | 建造者模式可能导 | 原型模式需要实现 |
| | 致全局状态的 | 每个产品类型创 | 度较高，实施困难 | 致更多的类的创 | `clone` 方法，且 |
| | 管理问题 | 建具体的工厂类 | | 建 | 依赖于具体实现 |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在全局配置、日志记录、数据库连接等场景中非常有用。
代码示例
class Singleton:_instance = None@staticmethoddef get_instance():if Singleton._instance is None:Singleton._instance = Singleton()return Singleton._instancedef __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):@abstractmethoddef 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()) # 输出: ConcreteProductAproduct_b = factory.create_product("B")
print(product_b.operation()) # 输出: ConcreteProductB
3. 抽象工厂模式（Abstract Factory）
抽象工厂模式提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。这种模式适用于多个产品族（Product Families）的场合。
代码示例
from abc import ABC, abstractmethod# 抽象产品类
class AbstractProductA(ABC):@abstractmethoddef operation_a(self):passclass AbstractProductB(ABC):@abstractmethoddef 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):@abstractmethoddef create_product_a(self):pass@abstractmethoddef 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()) # 输出: ConcreteProductB1factory2 = 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):@abstractmethoddef build_part_a(self):pass@abstractmethoddef build_part_b(self):pass@abstractmethoddef 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.productclass 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 B1director.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 = namedef clone(self):return copy.deepcopy(self)def __str__(self):return f"ConcretePrototype1: {self.name}"class ConcretePrototype2(Prototype):def __init__(self, name):self.name = namedef 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: Prototype1prototype2 = ConcretePrototype2("Prototype2")
new_prototype2 = prototype2.clone()
print(new_prototype2) # 输出: ConcretePrototype2: Prototype2
总结
创建模式是设计模式中的一种重要类型，它们关注对象的创建过程，提供了一种更灵活、可维护的方式来创建对象。通过使用单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式，我们可以有效地解决在对象创建过程中遇到的多种问题，提高代码的质量和可扩展性。
- 单例模式：确保一个类只有一个实例，并提供一个全局访问点。
- 工厂模式：提供创建对象的接口，由子类决定实例化哪个类。
- 抽象工厂模式：提供创建一系列相关或依赖对象的接口，无需指定具体类。
- 建造者模式：将复杂对象的构建与表示分离，使同样的构建过程可以创建不同的表示。
- 原型模式：通过复制现有对象来创建新对象，避免重复的初始化过程。希望你喜欢这篇文章！
- 请点关注和收藏吧。你的关注和收藏会是我努力更新的动力，祝关注和收藏的帅哥美女们今年都能暴富。如果有更多问题，欢迎随时提问