swift设计模式学习 - 策略模式

策略模式

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

策略模式的组成

  • 抽象策略角色(Strategy): 策略类,通常由一个接口或者抽象类实现。
  • 具体策略角色(ConcreteStrategy):包装了相关的算法和行为。
  • 环境角色(Context):持有一个策略类的引用,最终给客户端调用。

策略模式的基本实现

上图是最基本的装饰模式的结构图,下面将用Swift代码来实现一个基本策略模式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 策略类,定义所有支持 的算法的公共接口
protocol Strategy {
func AlgorithmInterface()
}

// 具体策略类,封装了具体的算法或行为,继承于Strategy
class ConcreteStrategyA: Strategy {
func AlgorithmInterface() {
print("ConcreteStrategyA")
}
}

class ConcreteStrategyB: Strategy {
func AlgorithmInterface() {
print("ConcreteStrategyB")
}
}

class ConcreteStrategyC: Strategy {
func AlgorithmInterface() {
print("ConcreteStrategyC")
}
}

// Context上下文,用一个 ConcreteStrategy来配置,维护一个对Strategy对象的引用
class Context {
var strategy: Strategy?
func ContextInterface() {
strategy?.AlgorithmInterface()
}
}

以上代码是最简单的策略模式的实现过程,定义了一个Strategy的算法族,通过它的子类可以实现算法(AlgorithmInterface)的替换,而不会影响到客户端。

用策略模式解决实际问题(商场打折)

我们知道在商场中一般有很多打折优惠方案,类似这种问题就可以用策略模式来解决,打折不同的方案就相当于不同的策略(ConcreteStrategy),然后用一个Context类来实现不同算法的切换,下面是商场打折策略模式的实现于UML图:

以上是一个简单的商场收银系统,CashNormal为普通收费子类,CashRebate为打折收费子类,CashReturn为返利收费子类,下面是代码的实现过程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import Foundation

// 定义一个收费的策略接口
protocol CashSuper {
func acceptCash(money: Double) -> Double
}

// 普通收费子类
class CashNormal: CashSuper {
// 正常原价返回
func acceptCash(money: Double) -> Double {
return money
}
}

// 打折收费子类
class CashRebate: CashSuper {
// 折扣率
private var moneyRebate: Double = 1.0

init(moneyRebate: Double) {
self.moneyRebate = moneyRebate
}

func acceptCash(money: Double) -> Double {
return money*moneyRebate
}
}

// 返利收费子类
class CashReturn: CashSuper {
// 返利要求
private var moneyCondition: Double = 0
// 返多少
private var moneyReturn: Double = 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
}
}


// context类
class CashContext {
private var cs: CashSuper?

// 通过枚举判断使用哪种方式
init(style: CashStyle) {
switch style {
case .normal:
cs = CashNormal()
case .rebate(moneyRebate: let money):
cs = CashRebate(moneyRebate: money)
case .return(moneyCondition: let moneyCondition, moneyReturn: let moneyReturn):
cs = CashReturn(moneyCondition: moneyCondition, moneyReturn: moneyReturn)
}
}

func getResult(money: Double) -> Double {
return cs?.acceptCash(money: money) ?? 0
}
}

// 优惠的枚举类型
enum CashStyle {
case normal
case rebate(moneyRebate: Double)
case `return`(moneyCondition: Double, moneyReturn: Double)
}

下面我们测试一下代码:

1
2
3
4
5
6
7
8
9
10
let money: Double = 300
// 普通
let normal = CashContext(style: .normal)
// 打7折
let rebate = CashContext(style: .rebate(moneyRebate: 0.7))
// 满一百返20
let `return` = CashContext(style: .return(moneyCondition: 100, moneyReturn: 20))
print("普通: \(normal.getResult(money: money))")
print("打8折: \(rebate.getResult(money: money))")
print("满一百返20: \(`return`.getResult(money: money))")

下面是执行的结果:

1
2
3
普通: 300.0
8折: 210.0
满一百返20: 240.0

策略模式总结

我们可以理解为策略就是用来封装算法,但在实践过程中不用那么死板,可以用来封装几乎任何类型的规则,只要在分析过程中听到需要在不同时间应用不同的业务规则,就可以考虑使用策略模式处理这种变化的可能性。

以上是我对于策略模式的理解,如果有不对的地方欢迎大家交流,最后谢谢大家的阅读~~


作者 @W_C__L
2017 年 02月 18日

简单不先于复杂,而是在复杂之后~~