设计模式 -- 工厂方法模式

表述 (创建型模式)

定义创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类

工厂方法模式和简单工厂十分类似，大致结构是基本类似的。不同在于工厂方法模式对工厂类进行了进一步的抽象，将之前的一个工厂类抽象成了抽象工厂和工厂子类，抽象工厂定义一个创建抽象子类的接口，抽象工厂的子类实现这些接口并决定实例化哪个抽象子类。工厂子类决定着创建哪个抽象子类，外界决定着创建哪种工厂子类，抽象子类和工厂子类是一一对应的

工厂方法模式类图

工厂方法模式类图

Creator（工厂抽象类）：定义创建抽象子类的接口，通过接口返回具体的抽象子类
ConcreteCreator（工厂子类）：继承自工厂抽象类，并重写父类的方法来创建对应的抽象子类
Product（抽象类）：定义抽象子类所需的属性和方法，子类通过继承自抽象类获取这些方法
ConcreteProduct（抽象子类）：继承自抽象类，是具体操作的实现者

优点

• 创建一个具体产品的细节完全封装在具体工厂内部，符合高内聚，低耦合
• 扩展性好，当需要扩展时，在代码中新建相应的工厂和产品类即可，前台代码无需更改

使用场景

• 编译时无法准确预期要创建的对象的类
• 类想让其子类决定在运行时创建什么
• 类有若干辅助类为其子类，而你想将返回哪个子类这一信息局部化

示例

需求V1：实现俩个数的加、减运算

//创建一个抽象类，抽象类中包含了参与运算的抽象子类的属性和方法
class Operation {
    private var _numA = 0
    private var _numB = 0
    
    var numA: Int{
        get{
            return _numA
        }
        set{
            _numA = newValue
        }
    }
    var numB: Int {
        get{
            return _numB
        }
        set{
            _numB = newValue
        }
    }
    func getResult() -> Int {
        return 0
    }
}

//创建负责运算的抽象子类
class OperationAdd:Operation {
    override func getResult() -> Int {
        return self.numA + self.numB
    }
}
//创建负责运算的抽象子类
class OperationSub:Operation {
    override func getResult() -> Int {
        return self.numA - self.numB
    }
}

//创建一个抽象工厂类，定义了实例化实际运算的方法
class CreateOperationFactory {
    func createOperationFactory() -> Operation {
        return Operation()
    }
}
//由子类继承并实例化不同的运算类
class OperationAddFactory : CreateOperationFactory {
    override func createOperationFactory() -> Operation {
        return OperationAdd()
    }
}
//由子类继承并实例化不同的运算类
class OperationSubFactory : CreateOperationFactory {
    override func createOperationFactory() -> Operation {
        return OperationSub()
    }
}

//直接实例化某个工厂子类,通过外界实例化某个工厂子类来选择具体的运算
let operAddFac = OperationAddFactory()
let operAdd = operAddFac.createOperationFactory()
operAdd.numA = 8
operAdd.numB = 5
let resAdd = operAdd.getResult()
print(resAdd)

let operSubFac = OperationSubFactory()
let operSub = operSubFac.createOperationFactory()
operSub.numA = 8
operSub.numB = 5
let resSub = operSub.getResult()
print(resSub)

需求V2：要在原有基础上添加乘法（对应新增的抽象子类创建对应的工厂子类即可）

class operationMul:Operation {
    override func getResult() -> Int {
        return self.numA * self.numB
    }
}

class OperationMulFactory : CreateOperationFactory {
    override func createOperationFactory() -> Operation {
        return operationMul()
    }
}

let operMulFac = OperationMulFactory()
let operMul = operMulFac.createOperationFactory()
operMul.numA = 8
operMul.numB = 5
let resMul = operMul.getResult()
print(resMul)

简单工厂模式违背了开放封闭原则，每次添加和删除抽象子类的时候，都需要对工厂类进行操作，这样不仅对工厂类的扩展开放了，还开放了工厂类的修改，这就是违背开放封闭原则的。因为按照开放封闭原则，新增加一个需求，应该是在原有类的基础上进行扩展，而不是对原有类进行修改。这样整个模式在生成新算法类时，只是进行扩展而不对模式中原有的代码进行修改，这就是符合开放封闭原则的