游牧学院

1.5 设计原则与设计模式的关系
2.2 单例模式（Singleton）

创建型设计模式概述

创建型设计模式是设计模式中的一种分类，主要关注对象的创建过程。这些模式通过提供一种适当的方式来创建对象，帮助我们在系统中实现更好的灵活性和可维护性。创建型模式的主要目标是将对象的创建与使用分离，从而使得系统在面对变化时更加灵活。

创建型设计模式的分类

创建型设计模式主要包括以下五种：

  1. 单例模式（Singleton）
  2. 工厂方法模式（Factory Method）
  3. 抽象工厂模式（Abstract Factory）
  4. 建造者模式（Builder）
  5. 原型模式（Prototype）

接下来，我们将逐一详细介绍每种模式，包括其优缺点、使用场景以及示例代码。

1. 单例模式（Singleton）

概述

单例模式确保一个类只有一个实例，并提供一个全局访问点。它通常用于需要控制资源的共享，例如数据库连接或配置对象。

优点

  • 全局访问：提供一个全局访问点，方便管理。
  • 节省资源：避免了重复创建对象，节省了内存和资源。

缺点

  • 难以测试：由于全局状态的存在，单元测试可能会变得复杂。
  • 并发问题：在多线程环境下，可能会出现多个实例的情况。

注意事项

  • 确保线程安全，避免在多线程环境下创建多个实例。

示例代码

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 使用示例
singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # 输出: True

2. 工厂方法模式（Factory Method）

概述

工厂方法模式定义一个创建对象的接口，但由子类决定要实例化的类。工厂方法将对象的实例化推迟到子类。

优点

  • 解耦：客户端代码与具体类解耦，便于扩展。
  • 灵活性：可以在运行时决定实例化哪个类。

缺点

  • 类的数量增加：每个产品都需要一个具体的工厂类，可能导致类的数量增加。
  • 复杂性：引入了额外的层次，增加了系统的复杂性。

注意事项

  • 确保工厂方法的返回类型是接口或抽象类，以便于扩展。

示例代码

from abc import ABC, abstractmethod

class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteProductA(Product):
    def operation(self):
        return "Result of ConcreteProductA"

class ConcreteProductB(Product):
    def operation(self):
        return "Result of ConcreteProductB"

class Creator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def some_operation(self):
        product = self.factory_method()
        return product.operation()

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

# 使用示例
creator_a = ConcreteCreatorA()
print(creator_a.some_operation())  # 输出: Result of ConcreteProductA

creator_b = ConcreteCreatorB()
print(creator_b.some_operation())  # 输出: Result of ConcreteProductB

3. 抽象工厂模式（Abstract Factory）

概述

抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。它通常用于需要创建多个产品族的场景。

优点

  • 产品族一致性：确保同一产品族中的对象可以协同工作。
  • 易于扩展：增加新的产品族时，只需添加新的工厂类。

缺点

  • 复杂性：引入了额外的层次，增加了系统的复杂性。
  • 难以支持新产品：如果需要添加新产品，可能需要修改多个类。

注意事项

  • 确保产品族之间的兼容性。

示例代码

from abc import ABC, abstractmethod

class AbstractProductA(ABC):
    @abstractmethod
    def useful_function_a(self):
        pass

class AbstractProductB(ABC):
    @abstractmethod
    def useful_function_b(self):
        pass

class ConcreteProductA1(AbstractProductA):
    def useful_function_a(self):
        return "Result of ProductA1"

class ConcreteProductA2(AbstractProductA):
    def useful_function_a(self):
        return "Result of ProductA2"

class ConcreteProductB1(AbstractProductB):
    def useful_function_b(self):
        return "Result of ProductB1"

class ConcreteProductB2(AbstractProductB):
    def useful_function_b(self):
        return "Result of ProductB2"

class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self) -> AbstractProductA:
        pass

    @abstractmethod
    def create_product_b(self) -> AbstractProductB:
        pass

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA1()

    def create_product_b(self) -> AbstractProductB:
        return ConcreteProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA2()

    def create_product_b(self) -> AbstractProductB:
        return ConcreteProductB2()

# 使用示例
factory1 = ConcreteFactory1()
product_a1 = factory1.create_product_a()
product_b1 = factory1.create_product_b()

print(product_a1.useful_function_a())  # 输出: Result of ProductA1
print(product_b1.useful_function_b())  # 输出: Result of ProductB1

4. 建造者模式（Builder）

概述

建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。它通常用于构建复杂对象的场景。

优点

  • 分离复杂性：将复杂对象的构建过程与表示分离，简化了对象的创建。
  • 可读性：通过链式调用，增强了代码的可读性。

缺点

  • 类的数量增加：每个具体建造者都需要一个类，可能导致类的数量增加。
  • 复杂性：引入了额外的层次，增加了系统的复杂性。

注意事项

  • 确保建造者的接口一致，以便于使用。

示例代码

class Product:
    def __init__(self):
        self.parts = []

    def add(self, part):
        self.parts.append(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 ConcreteBuilder(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("Part A")

    def build_part_b(self):
        self.product.add("Part B")

    def get_result(self):
        return self.product

class Director:
    def __init__(self, builder: Builder):
        self.builder = builder

    def construct(self):
        self.builder.build_part_a()
        self.builder.build_part_b()

# 使用示例
builder = ConcreteBuilder()
director = Director(builder)
director.construct()
product = builder.get_result()

print(product.parts)  # 输出: ['Part A', 'Part B']

5. 原型模式（Prototype）

概述

原型模式通过复制现有的实例来创建新对象，而不是通过类的构造函数。它通常用于需要大量相似对象的场景。

优点

  • 性能：通过复制现有对象，避免了昂贵的对象创建过程。
  • 灵活性：可以在运行时动态地创建对象。

缺点

  • 复杂性：需要实现克隆方法，增加了复杂性。
  • 深拷贝问题：需要处理深拷贝和浅拷贝的问题。

注意事项

  • 确保克隆方法的实现正确，避免共享可变状态。

示例代码

import copy

class Prototype:
    def clone(self):
        return copy.deepcopy(self)

class ConcretePrototype(Prototype):
    def __init__(self, value):
        self.value = value

# 使用示例
prototype = ConcretePrototype("Original")
clone = prototype.clone()

print(clone.value)  # 输出: Original

总结

创建型设计模式为我们提供了多种灵活的对象创建方式，帮助我们在系统中实现更好的可维护性和扩展性。每种模式都有其独特的优缺点和适用场景，开发者应根据具体需求选择合适的模式。在实际开发中，合理运用这些模式可以显著提高代码的质量和可读性。

1.5 设计原则与设计模式的关系
2.2 单例模式（Singleton）