简单工厂、工厂、抽象工厂

解决问题：客户端不想让创建一个实例的过程过于复杂（可能有很复杂的构造函数）。定义一个类专门用来处理类的实例化，在任何需要生成复杂对象的地方，都可以使用工厂模式。

• 简单工厂：唯一工厂类，一个产品抽象类，工厂类的创建方法依据入参判断并创建具体产品对象。
• 工厂方法：多个工厂类，一个产品抽象类，利用多态创建不同的产品对象，避免了大量的if-else判断。
• 抽象工厂：多个工厂类，多个产品抽象类，产品子类分组，同一个工厂实现类创建同组中的不同产品，减少了工厂子类的数量。

在下述情况下可以考虑使用工厂模式：

• 在编码时不能预见需要创建哪种类的实例。
• 系统不应依赖于产品类实例如何被创建、组合和表达的细节

# 简单工厂
# 缺点：如果增加新的产品类型，就需要在if-else里增加语句，扩展性差。
# 适用于业务简单，不太会扩展的场景。
class AbstractProduct:
    def method(self):
        pass


class ProductA(AbstractProduct):
    def method(self):
        pass


class ProductB(AbstractProduct):
    def method(self):
        pass


class ProductC(AbstractProduct):
    def method(self):
        pass


class ProductFactory():
    def createProduct(self, product_name):
        if product_name == 'A':
            return ProductA()
        elif product_name == 'B':
            return ProductB()
        elif product_name == 'C':
            return ProductC()
        return None


# 工厂
# 每个产品都有一个对应的工厂子类
# 这样，有一个新产品加入，只需要新建工厂子类，而不需要修改原来的类
# 缺点：每个产品对应一个工厂类，会使代码中的类越来越多，增加了代码复杂度
class AbstractProduct:
    def method(self):
        pass


class ProductA(AbstractProduct):
    def method(self):
        pass


class ProductB(AbstractProduct):
    def method(self):
        pass


class ProductC(AbstractProduct):
    def method(self):
        pass


class AbstractProductFactory():
    def createProduct(self):
        pass


class ProductAFactory(AbstractProductFactory):
    def createProduct(self):
        return ProductA()


class ProductBFactory(AbstractProductFactory):
    def createProduct(self, ):
        return ProductB()


class ProductCFactory(AbstractProductFactory):
    def createProduct(self):
        return ProductC()


# 抽象工厂
# 可以将产品进行分组，每组中的不同产品由同一个工厂类的不同方法创建
# 优缺点：增加分组很简单，分组中的产品扩展比较困难，既要增加产品抽象类，还要增加具体实现，每个factory都要定义获取新产品的方法
class AbstractProduct1:
    def method(self):
        pass


class AbstractProduct2:
    def method(self):
        pass


class ProductA1(AbstractProduct1):
    def method(self):
        pass


class ProductB1(AbstractProduct1):
    def method(self):
        pass


class ProductA2(AbstractProduct2):
    def method(self):
        pass


class ProductB2(AbstractProduct2):
    def method(self):
        pass


class AbstractProductFactory():
    def createProduct1(self):
        pass

    def createProduct2(self):
        pass


class ProductAFactory(AbstractProductFactory):
    def createProduct1(self):
        return ProductA1()

    def createProduct2(self):
        return ProductA2()


class ProductBFactory(AbstractProductFactory):
    def createProduct1(self):
        return ProductB1()

    def createProduct2(self):
        return ProductB2()


# 总结：
# 简单工厂：唯一工厂类，一个产品抽象类，工厂类的创建方法依据入参判断并创建具体产品对象。
# 工厂方法：多个工厂类，一个产品抽象类，利用多态创建不同的产品对象，避免了大量的if-else判断。
# 抽象工厂：多个工厂类，多个产品抽象类，产品子类分组，同一个工厂实现类创建同组中的不同产品，减少了工厂子类的数量。
#
#
# 在下述情况下可以考虑使用工厂模式：
# 在编码时不能预见需要创建哪种类的实例。
# 系统不应依赖于产品类实例如何被创建、组合和表达的细节