这章会引用到 简单工厂模式的代码,主要就是用来区分 简单工厂模式与工厂方法模式的区别
简单工厂模式请自行跳转
//www.greatytc.com/p/4b6f0bf57de9

工厂方法模式基本逻辑

// 运算基类
class Operation: NSObject {
    private var _numberA:Double = 0
    private var _numberB:Double = 0
    var numberA:Double {
        set{
            _numberA = newValue
        }
        get{
            return _numberA
        }
    }
    
    var numberB:Double {
        set{
            _numberB = newValue
        }
        get{
            return _numberB
        }
    }
    
    func getResult() -> Double {
        var  result:Double = 0
        return result
    }
}

// 运算子类
class OperationAdd: Operation {
    // 加法运算类
    override func getResult()->Double{
        var result:Double = 0
        result = numberA + numberB
        return result
    }
}

class OperationSub: Operation {
    // 减法运算类
    override func getResult() -> Double {
        var result:Double = 0
        result = numberA - numberB
        return result
    }
}

class OperationMul: Operation {
    // 乘法运算类
    override func getResult() -> Double {
        var result:Double = 0
        result = numberA * numberB
        return result
    }
}

class OperationDiv: Operation {
    // 除法运算类
    override func getResult() -> Double {
        var result:Double = 0
        if numberB != 0 {
            result = numberA / numberB
        } else {
            result = 0
        }
        return result
    }
}

// 工厂协议及工厂类
protocol IFactory {
    func createOperation()->Operation
}

class AddFactory:IFactory {
    func createOperation() -> Operation {
        return OperationAdd()
    }
}
class SubFactory:IFactory {
    func createOperation() -> Operation {
        return OperationSub()
    }
}
class MulFactory:IFactory {
    func createOperation() -> Operation {
        return OperationMul()
    }
}
class DivFactory:IFactory {
    func createOperation() -> Operation {
        return OperationDiv()
    }
}

// 客户端代码
class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        let operFactory = AddFactory()
        let oper = operFactory.createOperation()
        oper.numberA = 1
        oper.numberB = 2
        var result:Double = oper.getResult()
        print("结果是:",result);
        // 结果是: 3.0
    }
}

以上即是工厂方法模式的基本实现, 对比简单工厂模式,可以看出 如果简单工厂模式需要添加新的方法与逻辑时候, 需要添加相应的类,以及在工厂类里面添加相应的case判断逻辑, 这样其实违背了开放封闭原则;
在工厂方法模式中,就可以避免违背开放封闭原则,如果需要添加新的方法逻辑,不需要修改原有的工厂类,只需要增加此功能的运算类和相应的工厂类就可以了.
但是! 工厂方法模式实现时,客户端需要决定实例化哪一个工厂类来实现运算类,选择判断的问题还是存在的, 也就是说, 工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行,你想要加功能,本来是修改工厂类的, 而现在是修改客户端代码!
这里需要用到反射的方法了,在之后的抽象工厂模式中会提到