跳转至

抽象工厂模式

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。抽象工厂模式通过定义一组接口来创建产品簇，产品簇内的每个具体工厂负责创建相应的具体产品。

抽象工厂模式的特点

  1. 产品族：产品族是一组相关或互相依赖的产品对象。
  2. 创建产品的接口：定义了一组创建不同产品的方法，而无需指定具体类。
  3. 独立变化：具体工厂和产品可以独立变化，不影响其他部分。
  4. 抽象工厂：提供一个用于创建一组相关或依赖对象的接口。

抽象工厂模式的结构

  1. 抽象工厂（Abstract Factory）：声明创建抽象产品对象的操作。
  2. 具体工厂（Concrete Factory）：实现创建具体产品对象的操作。
  3. 抽象产品（Abstract Product）：为每种产品声明一个接口。
  4. 具体产品（Concrete Product）：定义具体工厂创建的产品对象，实现抽象产品接口。

抽象工厂模式的Python实现

以下是抽象工厂模式在Python中的实现示例：

1. 定义抽象产品和具体产品类

from abc import ABC, abstractmethod

# 抽象产品A
class AbstractProductA(ABC):
    @abstractmethod
    def useful_function_a(self) -> str:
        pass

# 具体产品A1
class ConcreteProductA1(AbstractProductA):
    def useful_function_a(self) -> str:
        return "The result of the product A1."

# 具体产品A2
class ConcreteProductA2(AbstractProductA):
    def useful_function_a(self) -> str:
        return "The result of the product A2."

# 抽象产品B
class AbstractProductB(ABC):
    @abstractmethod
    def useful_function_b(self) -> str:
        pass

# 具体产品B1
class ConcreteProductB1(AbstractProductB):
    def useful_function_b(self) -> str:
        return "The result of the product B1."

# 具体产品B2
class ConcreteProductB2(AbstractProductB):
    def useful_function_b(self) -> str:
        return "The result of the product B2."

2. 定义抽象工厂和具体工厂类

# 抽象工厂
class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self) -> AbstractProductA:
        pass

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

# 具体工厂1
class ConcreteFactory1(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA1()

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

# 具体工厂2
class ConcreteFactory2(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA2()

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

3. 客户端代码

def client_code(factory: AbstractFactory) -> None:
    product_a = factory.create_product_a()
    product_b = factory.create_product_b()

    print(f"{product_a.useful_function_a()}")
    print(f"{product_b.useful_function_b()}")

if __name__ == "__main__":
    print("Client: Testing client code with the first factory type:")
    client_code(ConcreteFactory1())

    print("\nClient: Testing client code with the second factory type:")
    client_code(ConcreteFactory2())

运行结果

Client: Testing client code with the first factory type:
The result of the product A1.
The result of the product B1.

Client: Testing client code with the second factory type:
The result of the product A2.
The result of the product B2.

说明

  1. 抽象产品（AbstractProductA 和 AbstractProductB）：为产品族中的每种产品声明接口。
  2. 具体产品（ConcreteProductA1, ConcreteProductA2, ConcreteProductB1, ConcreteProductB2）：实现具体产品，提供具体实现。
  3. 抽象工厂（AbstractFactory）：声明创建产品对象的方法。
  4. 具体工厂（ConcreteFactory1 和 ConcreteFactory2）：实现创建具体产品对象的方法，生成具体产品。

通过抽象工厂模式，可以创建相关的对象家族，而不需要明确指定具体类，从而使得系统更具灵活性和可扩展性。该模式尤其适用于当系统需要处理多个系列的相关对象时，例如不同品牌的UI组件库、数据库访问接口等。

评论