《大话设计模式》第 1 章 - 简单工厂模式 的 Swift 实现。

问题

做一个计算器。客户端输入两个数字和运算符号，得到计算结果。

方案

1. 松耦合

把加减乘除等运算分离，修改其中一个不影响另外的几个，增加运算算法也不影响其他代码。

class Operation{
    private var _numberA: Double = 0
    private var _numberB: Double = 0
    
    var numberA: Double{
        get{
            return _numberA
        }
        set{
            _numberA = newValue
        }
    }
    
    var numberB: Double{
        get{
            return _numberB
        }
        set{
            _numberB = newValue
        }
    }
    
    func GetResult() -> Double{
        let 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 {
        guard numberB != 0 else {
            print("除数不能为 0")
            return 0
        }
        var result: Double = 0
        result = numberA / numberB
        return result
    }
}

2. 多态

工厂类封装业务，只需要输入运算符号，工厂就实例化出合适的对象，通过多态，返回运算类实现计算。

class OperationFactory{
    class func createOperate(operate: String) -> Operation?{
        var oper: Operation?
        
        switch operate {
        case "+":
            oper = OperationAdd()
        case "-":
            oper = OperationSub()
        case "*":
            oper = OperationMul()
        case "/":
            oper = OperationDiv()
        default: break
        }
        return oper
    }
}

测试

UI 层通过简单的方式调用运算类。

let op = OperationFactory.createOperate(operate: "+")
op?.numberA = 1
op?.numberB = 2
op?.GetResult()

playground