1.封裝

效果最差， 功能全在一起，不易維護和單元測試

class OperatorTool {
    class func calculate(_ num1: Double, _ operation: String, _ num2: Double) -> Double? {
        switch operation {
        case "+":
            return num1 + num2
        case "/":
            assert(num2 != 0, "除數不能為零")
            return num1 / num2
        default:
            return nil
        }
    }
}

// ==================使用==================
var operation = "+"; var num1: Double = 1; 

OperatorTool.calculate(num1,operation,num2)
}

2.繼承（協議）

功能分離，便于維護測試，但是多了個switch

protocol OperatorProtocol {
    var num1: Double { get }
    var num2: Double { get }
    func calculate() -> Double
}

class Addition: OperatorProtocol {
    var num1: Double
    var num2: Double

    init(_ num1: Double, _ num2: Double) {
        self.num1 = num1
        self.num2 = num2
    }

    func calculate() -> Double {
        return num1 + num2
    }
}

class Divide: OperatorProtocol {
    var num1: Double
    var num2: Double

    init(_ num1: Double, _ num2: Double) {
        self.num1 = num1
        self.num2 = num2
    }

    func calculate() -> Double {
        assert(num2 != 0, "除數不能為零")
        return num1 / num2
    }
}

// ==================使用==================
switch operation {
case "+":
    let a = Addition(num1, num2)
    a.calculate()
case "/":
    let d = Divide(num1, num2)
    d.calculate()
default:
    break
}

3.多態

利用簡單工廠模式， 解決了可惡的switch，但是暴露了OperatorProtocol和OperatorFactory兩個類

class OperatorFactory {
    class func createOperator(_ num1: Double, _ operation: String, _ num2: Double) -> OperatorProtocol? {
        switch operation {
        case "+":
            return Addition(num1, num2)
        case "/":
            return Divide(num1, num2)
        default:
            return nil
        }
    }
}

// ==================使用==================
var o = OperatorFactory.createOperator(num1, operation, num2)
o?.calculate()

4.策略模式

使用者只需了解一個類 OperatorContext 就可以完成功能，松耦合

class OperatorContext {

    private var anOperator: OperatorProtocol

    init(_ anOperator: OperatorProtocol) {
        self.anOperator = anOperator
    }

    convenience init?(_ num1: Double, _ operation: String, _ num2: Double) {
        switch operation {
        case "+":
            self.init(Addition(num1, num2))
        case "/":
            self.init(Divide(num1, num2))
        default:
            return nil
        }
    }

    // 建議用便利構造函數替代， 如上
    class func createOperator(_ num1: Double, _ operation: String, _ num2: Double) -> OperatorContext? {
        switch operation {
        case "+":
            return OperatorContext(Addition(num1, num2))
        case "/":
            return OperatorContext(Divide(num1, num2))
        default:
            return nil
        }
    }

    func calculate() -> Double {
        return anOperator.calculate()
    }
}

// ==================使用==================
var context = OperatorContext(num1, operation, num2)
context?.calculate()