yongchin's blog

1.什么是

工厂方法：定义一个创建对象的接口，但由子类决定需要实例化哪一个类。工厂方法使得子类实例化的过程推迟

抽象工厂：提供一个接口，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类

2.为什么

2.1场景举例：

工厂方法：所有生成对象的地方都可以使用、需要灵活且可扩展的框架的时候

抽象工厂：无需关心对象创建过程，系统有多于一个的产品族且每次只需要某个产品族、产品等级结构稳定

2.2优点:

工厂方法：用户只需关心产品对应的工厂；添加新产品只要添加一个具体工厂和具体产品（这符合开闭原则）

抽象工厂：增加新的产品族很容易

3如何建立

3.1角色

工厂方法：

Creator：抽象工厂
ConcreteCreator：具体工程
Product：抽象产品
ConcreteProduct：具体产品

抽象工厂：

AbstractFactory：抽象工厂
ConcreteFactory：具体工厂
AbstractProduct：抽象产品
ConcreteProduct：具体产品

3.2举例实现

工厂方法

from abc import ABC, abstractmethod


# 产品接口
class Product(ABC):
    @abstractmethod
    def operation(self) -> str:
        pass


# 具体产品
class ConcreteProductA(Product):
    def operation(self) -> str:
        return "ConcreteProductA operation"


class ConcreteProductB(Product):
    def operation(self) -> str:
        return "ConcreteProductB operation"


# 工厂接口
class Factory(ABC):
    @abstractmethod
    def create_product(self) -> Product:
        pass


# 具体工厂
class ConcreteFactoryA(Factory):
    def create_product(self) -> Product:
        return ConcreteProductA()


class ConcreteFactoryB(Factory):
    def create_product(self) -> Product:
        return ConcreteProductB()


# 客户端代码
def client_code(factory: Factory):
    product = factory.create_product()
    print(f"Client: {product.operation()}")


client_code(ConcreteFactoryA())
client_code(ConcreteFactoryB())

抽象工厂

from abc import ABC, abstractmethod


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


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


# 具体产品A1
class ProductA1(AbstractProductA):
    def operation_a(self) -> str:
        return "ProductA1 operation"


# 具体产品A2
class ProductA2(AbstractProductA):
    def operation_a(self) -> str:
        return "ProductA2 operation"


# 具体产品B1
class ProductB1(AbstractProductB):
    def operation_b(self) -> str:
        return "ProductB1 operation"


# 具体产品B2
class ProductB2(AbstractProductB):
    def operation_b(self) -> str:
        return "ProductB2 operation"


# 抽象工厂
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 ProductA1()

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


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

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


# 客户端代码
def client_code(factory: AbstractFactory):
    product_a = factory.create_product_a()
    product_b = factory.create_product_b()
    print(f"Client: {product_a.operation_a()}")
    print(f"Client: {product_b.operation_b()}")


client_code(ConcreteFactory1())
client_code(ConcreteFactory2())

3.3比较

工厂方法模式：每个具体工厂只实现 create_product 方法，创建一个产品。
抽象工厂模式：每个具体工厂实现两个方法 create_product_a 和 create_product_b，创建一组相关产品。

python设计模式 创造者模式-工厂方法&抽象工厂 温故而知新（二）