1. 概述
当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。
2. 解决的问题
主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同的一系列类当中，可以把复杂的逻辑判断简单化。
3. 模式中的角色
3.1 上下文环境（context）：它定义了客户程序需要的接口并维护一个具体状态角色的实例，将与状态相关的操作委托给当前的concrete state对象来处理。
3.2 抽象状态（state）：定义一个接口以封装使用上下文环境的的一个特定状态相关的行为。
3.3 具体状态（concrete state）：实现抽象状态定义的接口。
4. 模式解读
4.1 状态模式的类图
4.2 状态模式的代码实现
|
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
|
/// <summary>/// context类，维护一个concretestate子类的实例，这个实例定义当前的状态。/// </summary>public class context{ private state state; /// <summary> /// 定义context的初始状态 /// </summary> /// <param name="state"></param> public context(state state) { this.state = state; } /// <summary> /// 可读写的状态属性，用于读取和设置新状态 /// </summary> public state state { get { return state; } set { state = value; } } /// <summary> /// 对请求做处理，并设置下一个状态 /// </summary> public void request() { state.handle(this); }}/// <summary>/// 抽象状态类，定义一个接口以封装与context的一个特定状态相关的行为/// </summary>public abstract class state{ public abstract void handle(context context);}/// <summary>/// 具体状态类，每一个子类实现一个与context的一个状态相关的行为/// </summary>public class concretestatea : state{ /// <summary> /// 设置concretestatea的下一个状态是concretestateb /// </summary> /// <param name="context"></param> public override void handle(context context) { console.writeline("当前状态是 a."); context.state = new concretestateb(); }}public class concretestateb : state{ /// <summary> /// 设置concretestateb的下一个状态是concretesatea /// </summary> /// <param name="context"></param> public override void handle(context context) { console.writeline("当前状态是 b."); context.state = new concretestatea(); }} |
4.3 客户端调用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class program{ static void main(string[] args) { // 设置context的初始状态为concretestatea context context = new context(new concretestatea()); // 不断地进行请求，同时更改状态 context.request(); context.request(); context.request(); context.request(); console.read(); }} |
运行结果
5. 模式总结
5.1 优点
5.1.1 状态模式将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。
5.1.2 所有状态相关的代码都存在于某个conceretestate中，所以通过定义新的子类很容易地增加新的状态和转换。
5.1.3 状态模式通过把各种状态转移逻辑分不到state的子类之间，来减少相互间的依赖。
5.2 缺点
5.2.1 导致较多的concretestate子类
5.3 适用场景
5.3.1 当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式来。
5.3.2 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态。
6. 应用举例：电灯有两个状态，开（亮）与关（不亮），下面就用状态模式来实现对电灯的控制。
6.1 类图
6.2 实现代码
|
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
|
/// <summary>/// 电灯类，对应模式中的context类/// </summary>public class light{ private lightstate state; public light(lightstate state) { this.state = state; } /// <summary> /// 按下电灯开关 /// </summary> public void pressswich() { state.pressswich(this); } public lightstate state { get { return state; } set { state = value; } } }/// <summary>/// 抽象的电灯状态类，相当于state类/// </summary>public abstract class lightstate{ public abstract void pressswich(light light);}/// <summary>/// 具体状态类, 开/// </summary>public class on : lightstate{ /// <summary> /// 在开状态下，按下开关则切换到关的状态。 /// </summary> /// <param name="light"></param> public override void pressswich(light light) { console.writeline("turn off the light."); light.state = new off(); }}/// <summary>/// 具体状态类，关/// </summary>public class off: lightstate{ /// <summary> /// 在关状态下，按下开关则打开电灯。 /// </summary> /// <param name="light"></param> public override void pressswich(light light) { console.writeline("turn on the light."); light.state = new on(); }} |
6.3 客户端代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class program{ static void main(string[] args) { // 初始化电灯，原始状态为关 light light = new light(new off()); // 第一次按下开关，打开电灯 light.pressswich(); // 第二次按下开关，关闭电灯 light.pressswich(); console.read(); }} |
执行结果
