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