Design Patterns Talk - Strategy Pattern

《大话设计模式》第 2 章 - 策略模式 的 Swift 实现。

问题

做一个商场收银软件，根据不同促销方案返回不同的应收款金额。

解决

策略模式定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

1. Strategy 类，定义算法的公共接口

Swift 中没有抽象类，用一个协议来做声明，声明具体算法需要实现的方法。

//现金收费协议
protocol CashSuper{
    func acceptCash(money: Double) -> Double
}

2. ConcreteStrategy，封装具体的算法，继承于 Strategy

实现具体算法的各个类遵循 CashSuper 协议，实现协议方法。

// MARK: 运算类
//正常收费
final class CashNormal: CashSuper{
    func acceptCash(money: Double) -> Double {
        return money
    }
}

//打折收费
final class CashRebate: CashSuper{
    private var moneyRebate: Double = 1

    init(moneyRebate: Double) {
        self.moneyRebate = moneyRebate
    }
    
    func acceptCash(money: Double) -> Double {
        return money * moneyRebate
    }
}

//返利收费
final class CashReturn: CashSuper{
    private var moneyCondition: Double = 0.0
    private var moneyReturn: Double = 0.0
    
    init(moneyCondition: Double, moneyReturn: Double){
        self.moneyCondition = moneyCondition
        self.moneyReturn = moneyReturn
    }
    
    func acceptCash(money: Double) -> Double {
        var result = money
        if (money >= moneyCondition) {
            result = money - floor(money / moneyCondition) * moneyReturn
        }
        return result
    }
}

3. Context，传入 ConcreteStrategy，维护对 Strategy 的引用。

策略模式结合简单工厂，工厂根据传入的字符串生成对应的具体算法，实例化具体算法的过程由客户端转移到 context 类。然后通过调用 GetResult 方法得到计算结果，让具体算法与客户端隔离。

//策略模式结合简单工厂
final class CashContext{
    private var cs: CashSuper?
    
    init(type: String){
        switch type {
        case "正常收费":
            self.cs = CashNormal()
        case "满300返100":
            self.cs = CashReturn(moneyCondition: 300,moneyReturn: 100)
        case "打8折":
            self.cs = CashRebate(moneyRebate: 0.8)
        default:
            break
        }
    }
    
    func GetResult(money: Double) -> Double{
        guard let cs = cs else {
            return money
        }
        return cs.acceptCash(money: money)
    }
}

第一章简单工厂模式中，我们需要让客户端认识两个类，CashSuper 和 CashFactory，而策略模式与简单工厂模式结合的用法，客户端之需要认识一个类 CashContext 就可以了，连算法的父类(协议) CashSuper 都不让客户端认识。耦合度更低。

测试

let result1 = CashContext(type:"正常收费").GetResult(money: 580)
let result2 = CashContext(type:"满300返100").GetResult(money: 580)
let result3 = CashContext(type:"打8折").GetResult(money: 580)
print("总价：580，正常收费 = \(result1)； 满300返100 = \(result2)；打8折 = \(result3)")

总结

用相同的方法调用任何一个算法，减少各种算法类与使用算法类（客户端）之间的耦合。

当不同行为堆砌在一个类中时，很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的 Strategy 类中，就可以在使用行为的类中消除条件语句。

策略模式封装了变化。策略模式就是用来封装算法的，在实践中，它可以用来封装任何类型的规则，如果需求需要在不同时间应用不同的业务规则，那么就可以考虑用策略模式来处理这种变化的可能性。

source code