大话设计模式：第8章 工厂方法模式

第8章：工厂方法模式

简单工厂 v.s. 工厂方法

简单工厂模式

• 优点：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

• 局限：增加功能时，需要修改原有的工厂类，违背了开放-封装原则

在简单工厂模式中，由于工厂类与分支耦合，根据依赖倒转原则，应将工厂类抽象成一个接口，这个接口只有一个方法，就是创建抽象产品的工厂方法。然后，所有的要生产具体类的工厂，就去实现这个接口。这样，一个简单工厂模式的工厂类就变成了一个工厂抽象接口和多个具体生产对象的工厂。

工厂方法模式

工厂方法模式（factory method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。想要加功能，本来是修改工厂类的，而现在是修改客户端。

简单工厂模式和工厂方法模式是集中封装了对象的创建，使得更换对象时，不需要做大的改动就可实现，降低客户程序与产品对象的耦合。工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点，但工厂方法模式的缺点是由于每增加一个产品，就需要加增加一个产品工厂的类，增加了额外的开发量。

工厂方法模式示例

任务：计算器

• 简单工厂模式

• 工厂方法模式

from abc import ABC, abstractmethod
from typing import Text

class Operation(ABC):
    """
    an abstract base class for operation
    
    args:
        number_a (float)
        number_b (float)
        
    return:
        result (float)
    """
    
    def __init__(self) -> None:
        self._number_a = 0
        self._number_b = 0
    
    @abstractmethod
    def get_result(self) -> float:
        """
        please reimplement this method
        """
        
    @property
    def number_a(self) -> float:
        return self._number_a
    @number_a.setter
    def number_a(self, number: float) -> None:
        self._number_a = number
        
    @property
    def number_b(self) -> float:
        return self._number_b
    @number_b.setter
    def number_b(self, number: float) -> None:
        self._number_b = number
        
        
class OperationAdd(Operation):
    
    def __init__(self):
        pass
    
    def get_result(self) -> float:
        return number_a + number_b
    
class OperationSub(Operation):
    
    def __init__(self):
        pass
    
    def get_result(self) -> float:
        return self._number_a - self._number_b
    
class OperationMul(Operation):
    
    def __init__(self):
        pass
        
    def get_result(self) -> float:
        return self._number_a * self._number_b
    
class OperationDiv(Operation):
    
    def __init__(self):
        pass
        
    def get_result(self) -> float:
        assert self._number_b != 0, "exception: division by zero"
        return self._number_a / self._number_b

# 工厂接口

class IFactory(ABC):
    
    def __init__(self) -> None:
        pass
    
    @abstractmethod
    def create_operation(self) -> Operation:
        pass
    
    
class AddFactory(IFactory):
    
    def create_operation(self) -> Operation:
        return OperationAdd()
    
class MulFactory(IFactory):
    
    def create_operation(self) -> Operation:
        return OperationMul()
    
class SubFactory(IFactory):
    
    def create_operation(self) -> Operation:
        return OperationSub()
    
class DivFactory(IFactory):
    
    def create_operation(self) -> Operation:
        return OperationDiv()
    

# 客户端代码

if __name__ == "__main__":
    
    number_a = 1
    number_b = 2
    
    oper_factories = [AddFactory, SubFactory, MulFactory, DivFactory]
    operators = "+-*/"
    for operator, oper_fact in zip(operators, oper_factories):
        oper = oper_fact().create_operation()
        oper.number_a = number_a
        oper.number_b = number_b
        print(operator, ": ", oper.get_result())
        

+ :  3
- :  -1
* :  2
/ :  0.5