Python设计模式-01-工厂模式

工厂模式

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。工厂模式通过定义一个工厂接口来创建对象，让子类决定实例化哪个类。这样可以将对象的创建与使用分离，从而降低系统的耦合度。

工厂模式包含三种角色：

• 具体工厂（Concrete Factory）：实现了工厂接口，用于创建具体的产品。
• 产品（Product）：定义了工厂创建的对象的接口。

以下是一个简单的Python示例代码，演示了工厂模式的实现：

from abc import ABC, abstractmethod

# 抽象产品
class Product(ABC):
    @abstractmethod
    def use(self):
        pass

# 具体产品A
class ProductA(Product):
    def use(self):
        print("ProductA is used.")

# 具体产品B
class ProductB(Product):
    def use(self):
        print("ProductB is used.")

# 工厂
class Factory:
    def create_product(self, product_type):
        if product_type == "A":
            return ProductA()
        elif product_type == "B":
            return ProductB()
        else:
            raise ValueError("Invalid product type.")

# 客户端代码
factory = Factory()
product_a = factory.create_product("A")
product_a.use()

product_b = factory.create_product("B")
product_b.use()

抽象工厂

普通工厂模式和抽象工厂模式都是工厂模式的变体，它们的主要区别在于抽象工厂模式可以创建一组相关的产品，而普通工厂模式只能创建单一的产品。

普通工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。普通工厂模式通过定义一个工厂接口来创建对象，让子类决定实例化哪个类。这样可以将对象的创建与使用分离，从而降低系统的耦合度。

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建一组相关或相互依赖对象的最佳方式，而无需指定它们的具体类。抽象工厂模式通过定义一个工厂接口来创建对象，让子类决定实例化哪个类。这样可以将对象的创建与使用分离，从而降低系统的耦合度。

普通工厂模式只能创建单一的产品，而抽象工厂模式可以创建一组相关的产品。例如，一个汽车工厂可以生产多种型号的汽车，每种型号的汽车都由不同的部件组成。在普通工厂模式中，只能创建单一型号的汽车，而在抽象工厂模式中，可以创建一组相关的部件，从而生产多种型号的汽车。

另外，普通工厂模式只需要一个工厂类，而抽象工厂模式需要多个工厂类。在普通工厂模式中，工厂类负责创建单一的产品，而在抽象工厂模式中，每个工厂类负责创建一组相关的产品。

总之，普通工厂模式和抽象工厂模式都是工厂模式的变体，它们的主要区别在于抽象工厂模式可以创建一组相关的产品，而普通工厂模式只能创建单一的产品。选择哪种模式取决于具体的需求。

from abc import ABC, abstractmethod

# 抽象产品
class Product(ABC):
    @abstractmethod
    def use(self):
        pass

# 具体产品A
class ProductA(Product):
    def use(self):
        print("ProductA is used.")

# 具体产品B
class ProductB(Product):
    def use(self):
        print("ProductB is used.")

# 抽象工厂
class Factory(ABC):
    @abstractmethod
    def create_product(self):
        pass

# 具体工厂A
class FactoryA(Factory):
    def create_product(self):
        return ProductA()

# 具体工厂B
class FactoryB(Factory):
    def create_product(self):
        return ProductB()

# 客户端代码
factory_a = FactoryA()
product_a = factory_a.create_product()
product_a.use()

factory_b = FactoryB()
product_b = factory_b.create_product()
product_b.use()

在这个示例代码中，首先定义了抽象产品Product和抽象工厂Factory。然后定义了两个具体产品ProductA和ProductB，以及两个具体工厂FactoryA和FactoryB。最后在客户端代码中，分别使用FactoryA和FactoryB创建了ProductA和ProductB，并调用了它们的use方法。

工厂模式的优点在于它可以将对象的创建与使用分离，从而降低系统的耦合度。同时，工厂模式也可以很容易地扩展，只需要添加新的具体产品和具体工厂即可。