1. 概念

    简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

    1. 实质

      简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

    2. 该模式中包含的角色及其职责

    工厂（Creator）角色
    简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
    抽象产品（Product）角色
    简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
    具体产品（Concrete Product）角色
    是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

    1. 优点，缺点
    • 优点
      • 工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。
    • 缺点
      • 由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
      • 当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

    这些缺点在工厂方法模式中得到了一定的克服。

    1. 适用场景
    • 工厂类负责创建的对象比较少；
    • 客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心
    • 由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。
    1. class Operation:
    2.     """
    3.         抽象产品（Product）角色
    4.         简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
    5.     """
    6.     def __init__(self):
    7.         self._num_a = 0
    8.         self._num_b = 0
    10.     @property
    11.     def A(self):
    12.         return self._num_a
    13.     @A.setter
    14.     def A(self,A):
    15.         self._num_a = A
    17.     @property
    18.     def B(self):
    19.         return self._num_b
    21.     @B.setter
    22.     def B(self,B):
    23.         self._num_b = B
    26.     def get_result(self):
    27.         result = 0
    28.         return result
    29. #具体产品（Concrete Product）角色,是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
    30. class OperationAdd(Operation):
    31.     def get_result(self):
    32.         result = self.A + self.B
    33.         return result
    34. class OperationSub(Operation):
    35.     def get_result(self):
    36.         result = self.A - self.B
    37.         return result
    38. class OperationMul(Operation):
    39.     def get_result(self):
    40.         result = self.A * self.B
    41.         return result
    42. class OperationDiv(Operation):
    43.     def get_result(self):
    44.         if self.B == 0:
    45.             raise ValueError('除数不能为0')
    46.         result = self.A / self.B
    47.         return result
    48. # 抽象工厂,简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。
    49. # 工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
    50. class OperationFactory:
    51.     """
    52.     工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象
    53.     缺点：
    54.         1.由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中
    55.         2.它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
    56.         3.当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．
    57.             这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；
    58.     """
    59.     def create_operate(self,operate):
    60.         if operate == '+':
    61.             return OperationAdd()
    62.         elif operate == '-':
    63.             return OperationSub()
    64.         elif operate == '*':
    65.             return OperationMul()
    66.         elif operate == '/':
    67.             return OperationDiv()
    68.         else:
    69.             raise ValueError('请提供正确的运算类型')
    70. if __name__ == '__main__':
    71.     oper = OperationFactory()
    72.     oper_add = oper.create_operate('/')
    73.     oper_add.A = 10
    74.     oper_add.B = 2
    75.     print(oper_add.get_result())
    1. # @Email        :  wangbq_ki@163.com
    2. # @Time         :  2022-06-12
    3. # @File         :  test.py
    4. # @Description  :  Implement the simple factory pattern
    5. import string
    6. from abc import abstractmethod, ABC
    9. class Option:
    10.     """With object - oriented implementation of a calculator console procedures"""
    11.     __slots__ = ["_number_first", "_number_second"]
    13.     def __init__(self, _number_first, _number_second):
    14.         self._number_first = _number_first
    15.         self._number_second = _number_second
    17.     def get_number_first(self):
    18.         return self._number_first
    20.     def get_number_second(self):
    21.         return self._number_second
    23.     @abstractmethod
    24.     def get_result(self):
    25.         pass
    28. class OperationAdd(Option, ABC):
    29.     def get_result(self):
    30.         return self.get_number_first() + self.get_number_second()
    33. class OperationSub(Option, ABC):
    34.     def get_result(self):
    35.         if self.get_number_second() == 0:
    36.             raise Exception("除数不能为0")
    37.         return self.get_number_first() - self.get_number_second()
    40. class OperationMul(Option, ABC):
    41.     def get_result(self):
    42.         return self.get_number_first() * self.get_number_second()
    45. class OperationDiv(Option, ABC):
    46.     def get_result(self):
    47.         return self.get_number_first() / self.get_number_second()
    50. class OperationFactory:
    51.     def __init__(self, number_a, number_b):
    52.         self.number_first = number_a
    53.         self.number_second = number_b
    55.     def create_operate(self, operate: string) -> Option:
    56.         if operate == "+":
    57.             return OperationAdd(self.number_first, self.number_second)
    58.         elif operate == "-":
    59.             return OperationSub(self.number_first, self.number_second)
    60.         elif operate == "*":
    61.             return OperationMul(self.number_first, self.number_second)
    62.         elif operate == "/":
    63.             return OperationDiv(self.number_first, self.number_second)
    64.         else:
    65.             raise Exception("请输入正确的运算符！")
    68. if __name__ == '__main__':
    69.     number_first = int(input("请输入数字a: "))
    70.     number_second = int(input("请输入数字b: "))
    71.     ope = OperationFactory(number_first, number_second).create_operate("*")
    72.     print(ope.get_result())