《大话设计模式》第 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 类中，就可以在使用行为的类中消除条件语句。
策略模式封装了变化。策略模式就是用来封装算法的，在实践中，它可以用来封装任何类型的规则，如果需求需要在不同时间应用不同的业务规则，那么就可以考虑用策略模式来处理这种变化的可能性。
