表述 (创建型模式)
定义创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类
工厂方法模式和简单工厂十分类似，大致结构是基本类似的。不同在于工厂方法模式对工厂类进行了进一步的抽象，将之前的一个工厂类抽象成了抽象工厂和工厂子类，抽象工厂定义一个创建抽象子类的接口，抽象工厂的子类实现这些接口并决定实例化哪个抽象子类。工厂子类决定着创建哪个抽象子类，外界决定着创建哪种工厂子类，抽象子类和工厂子类是一一对应的
工厂方法模式类图
工厂方法模式类图
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)
简单工厂模式违背了开放封闭原则，每次添加和删除抽象子类的时候，都需要对工厂类进行操作，这样不仅对工厂类的扩展开放了，还开放了工厂类的修改，这就是违背开放封闭原则的。因为按照开放封闭原则，新增加一个需求，应该是在原有类的基础上进行扩展，而不是对原有类进行修改。这样整个模式在生成新算法类时，只是进行扩展而不对模式中原有的代码进行修改，这就是符合开放封闭原则的
网友评论