行为型：设计模式之状态模式（十八）

“人有悲欢离合，月有阴晴圆缺”，包括人在内，很多事物都具有多种状态，而且在不同状态下会具有不同的行为，这些状态在特定条件下还将发生相互转换。就像水，它可以凝固成冰，也可以受热蒸发后变成水蒸汽，水可以流动，冰可以雕刻，蒸汽可以扩散。我们可以用UML状态图来描述H₂O的三种状态，如图1所示：

图1 H₂O的三种状态（未考虑临界点）

       在软件系统中，有些对象也像水一样具有多种状态，这些状态在某些情况下能够相互转换，而且对象在不同的状态下也将具有不同的行为。为了更好地对这些具有多种状态的对象进行设计，我们可以使用一种被称之为状态模式的设计模式，本章我们将学习用于描述对象状态及其转换的状态模式。

1. 银行系统中的账户类设计

       Sunny软件公司开发人员对银行账户类进行分析，绘制了如图2所示UML状态图：

图2 银行账户状态图

       在图2中，NormalState表示正常状态，OverdraftState表示透支状态，RestrictedState表示受限状态，在这三种状态下账户对象拥有不同的行为，方法deposit()用于存款，withdraw()用于取款，computeInterest()用于计算利息，stateCheck()用于在每一次执行存款和取款操作后根据余额来判断是否要进行状态转换并实现状态转换，相同的方法在不同的状态中可能会有不同的实现。为了实现不同状态下对象的各种行为以及对象状态之间的相互转换，Sunny软件公司开发人员设计了一个较为庞大的账户类Account，其中部分代码如下所示：

1. class Account {  
2. private String state; //状态  
3. private int balance; //余额  
4.     ......  
5.       
6. //存款操作    
7. public void deposit() {  
8. //存款  
9.         stateCheck();     
10.     }  
11.       
12. //取款操作  
13. public void withdraw() {  
14. if (state.equalsIgnoreCase("NormalState") || state.equalsIgnoreCase("OverdraftState ")) {  
15. //取款  
16.             stateCheck();  
17.         }  
18. else {  
19. //取款受限  
20.         }  
21.     }  
22.       
23. //计算利息操作  
24. public void computeInterest() {  
25. if(state.equalsIgnoreCase("OverdraftState") || state.equalsIgnoreCase("RestrictedState ")) {  
26. //计算利息  
27.         }  
28.     }  
29.       
30. //状态检查和转换操作  
31. public void stateCheck() {  
32. if (balance >= 0) {  
33. "NormalState";  
34.         }  
35. else if (balance > -2000 && balance < 0) {  
36. "OverdraftState";  
37.         }  
38. else if (balance == -2000) {  
39. "RestrictedState";  
40.         }  
41. else if (balance < -2000) {  
42. //操作受限  
43.         }  
44.     }  
45.     ......  
46. }  

       分析上述代码，我们不难发现存在如下几个问题：

       (1) 几乎每个方法中都包含状态判断语句，以判断在该状态下是否具有该方法以及在特定状态下该方法如何实现，导致代码非常冗长，可维护性较差；

       (2) 拥有一个较为复杂的stateCheck()方法，包含大量的if…else if…else…语句用于进行状态转换，代码测试难度较大，且不易于维护；

       (3) 系统扩展性较差，如果需要增加一种新的状态，如冻结状态（Frozen State，在该状态下既不允许存款也不允许取款），需要对原有代码进行大量修改，扩展起来非常麻烦。

       为了解决这些问题，我们可以使用状态模式，在状态模式中，我们将对象在每一个状态下的行为和状态转移语句封装在一个个状态类中，通过这些状态类来分散冗长的条件转移语句，让系统具有更好的灵活性和可扩展性，状态模式可以在一定程度上解决上述问题。

2 状态模式概述

      状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理。

       状态模式定义如下：

3所示：

图3 状态模式结构图

在状态模式结构图中包含如下几个角色：

    Context（环境类）：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

      State（抽象状态类）：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

      ConcreteState（具体状态类）：它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

       在状态模式中，我们将对象在不同状态下的行为封装到不同的状态类中，为了让系统具有更好的灵活性和可扩展性，同时对各状态下的共有行为进行封装，我们需要对状态进行抽象，引入了抽象状态类角色，其典型代码如下所示：

1. public abstract class State {  
2. //声明抽象业务方法，不同的具体状态类可以不同的实现  
3. public abstract void handle();  
4. }  

在抽象状态类的子类即具体状态类中实现了在抽象状态类中声明的业务方法，不同的具体状态类可以提供完全不同的方法实现，在实际使用时，在一个状态类中可能包含多个业务方法，如果在具体状态类中某些业务方法的实现完全相同，可以将这些方法移至抽象状态类，实现代码的复用，典型的具体状态类代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. public class ConcreteState extends State {  
2. public void handle() {  
3. //方法具体实现代码  
4.     }  
5. }  

setState()方法可以向环境类注入不同的状态对象，再在环境类的业务方法中调用状态对象的方法，典型代码如下所示：

1. public class Context {  
2. private State state; //维持一个对抽象状态对象的引用  
3. private int value; //其他属性值，该属性值的变化可能会导致对象状态发生变化  
4.   
5. //设置状态对象  
6. public void setState(State state) {  
7. this.state = state;  
8.     }  
9.   
10. public void request() {  
11. //其他代码  
12. //调用状态对象的业务方法  
13. //其他代码  
14.     }  
15. }  

环境类实际上是真正拥有状态的对象，我们只是将环境类中与状态有关的代码提取出来封装到专门的状态类中。在状态模式结构图中，环境类Context与抽象状态类State之间存在单向关联关系，在Context中定义了一个State对象。在实际使用时，它们之间可能存在更为复杂的关系，State与Context之间可能也存在依赖或者关联关系。

       在状态模式的使用过程中，一个对象的状态之间还可以进行相互转换，通常有两种实现状态转换的方式：

       (1) 统一由环境类来负责状态之间的转换，此时，环境类还充当了状态管理器(State Manager)角色，在环境类的业务方法中通过对某些属性值的判断实现状态转换，还可以提供一个专门的方法用于实现属性判断和状态转换，如下代码片段所示：

1. ……  
2. public void changeState() {  
3. //判断属性值，根据属性值进行状态转换  
4. if (value == 0) {  
5. this.setState(new ConcreteStateA());  
6.     }  
7. else if (value == 1) {  
8. this.setState(new ConcreteStateB());  
9.     }  
10.        ......  
11. }  
12.    ……  

  (2) 由具体状态类来负责状态之间的转换，可以在具体状态类的业务方法中判断环境类的某些属性值再根据情况为环境类设置新的状态对象，实现状态转换，同样，也可以提供一个专门的方法来负责属性值的判断和状态转换。此时，状态类与环境类之间就将存在依赖或关联关系，因为状态类需要访问环境类中的属性值，如下代码片段所示：

1. ……  
2. public void changeState(Context ctx) {  
3. //根据环境对象中的属性值进行状态转换  
4. if (ctx.getValue() == 1) {  
5. new ConcreteStateB());  
6.     }  
7. else if (ctx.getValue() == 2) {  
8. new ConcreteStateC());  
9.     }  
10.        ......  
11. }  
12.    ……  

3 完整解决方案

       Sunny软件公司开发人员使用状态模式来解决账户状态的转换问题，客户端只需要执行简单的存款和取款操作，系统根据余额将自动转换到相应的状态，其基本结构如图4所示：

图4 银行账户结构图

4中，Account充当环境类角色，AccountState充当抽象状态角色，NormalState、OverdraftState和RestrictedState充当具体状态角色。完整代码如下所示：

温馨提示：代码有点长，需要有耐心！

1. //银行账户：环境类  
2. public class Account {  
3. private AccountState state; //维持一个对抽象状态对象的引用  
4. private String owner; //开户名  
5. private double balance = 0; //账户余额  
6.       
7. public Account(String owner,double init) {  
8. this.owner = owner;  
9. this.balance = balance;  
10. this.state = new NormalState(this); //设置初始状态  
11. this.owner + "开户，初始金额为" + init);   
12. "---------------------------------------------");      
13.     }  
14.       
15. public double getBalance() {  
16. return this.balance;  
17.     }  
18.       
19. public void setBalance(double balance) {  
20. this.balance = balance;  
21.     }  
22.       
23. public void setState(AccountState state) {  
24. this.state = state;  
25.     }  
26.       
27. public void deposit(double amount) {  
28. this.owner + "存款" + amount);  
29. //调用状态对象的deposit()方法  
30. "现在余额为"+ this.balance);  
31. "现在帐户状态为"+ this.state.getClass().getName());  
32. "---------------------------------------------");              
33.     }  
34.       
35. public void withdraw(double amount) {  
36. this.owner + "取款" + amount);  
37. //调用状态对象的withdraw()方法  
38. "现在余额为"+ this.balance);  
39. "现在帐户状态为"+ this. state.getClass().getName());          
40. "---------------------------------------------");  
41.     }  
42.       
43. public void computeInterest()  
44.     {  
45. //调用状态对象的computeInterest()方法  
46.     }  
47. }  
48.   
49. //抽象状态类  
50. abstract class AccountState {  
51. protected Account acc;  
52. public abstract void deposit(double amount);  
53. public abstract void withdraw(double amount);  
54. public abstract void computeInterest();  
55. public abstract void stateCheck();  
56. }  
57.   
58. //正常状态：具体状态类  
59. class NormalState extends AccountState {  
60. public NormalState(Account acc) {  
61. this.acc = acc;  
62.     }  
63.   
64. public NormalState(AccountState state) {  
65. this.acc = state.acc;  
66.     }  
67.           
68. public void deposit(double amount) {  
69.         acc.setBalance(acc.getBalance() + amount);  
70.         stateCheck();  
71.     }  
72.       
73. public void withdraw(double amount) {  
74.         acc.setBalance(acc.getBalance() - amount);  
75.         stateCheck();  
76.     }  
77.       
78. public void computeInterest()  
79.     {  
80. "正常状态，无须支付利息！");  
81.     }  
82.       
83. //状态转换  
84. public void stateCheck() {  
85. if (acc.getBalance() > -2000 && acc.getBalance() <= 0) {  
86. new OverdraftState(this));  
87.         }  
88. else if (acc.getBalance() == -2000) {  
89. new RestrictedState(this));  
90.         }  
91. else if (acc.getBalance() < -2000) {  
92. "操作受限！");  
93.         }     
94.     }     
95. }    
96.   
97. //透支状态：具体状态类  
98. class OverdraftState extends AccountState {  
99. public OverdraftState(AccountState state) {  
100. this.acc = state.acc;  
101.     }  
102.       
103. public void deposit(double amount) {  
104.         acc.setBalance(acc.getBalance() + amount);  
105.         stateCheck();  
106.     }  
107.       
108. public void withdraw(double amount) {  
109.         acc.setBalance(acc.getBalance() - amount);  
110.         stateCheck();  
111.     }  
112.       
113. public void computeInterest() {  
114. "计算利息！");  
115.     }  
116.       
117. //状态转换  
118. public void stateCheck() {  
119. if (acc.getBalance() > 0) {  
120. new NormalState(this));  
121.         }  
122. else if (acc.getBalance() == -2000) {  
123. new RestrictedState(this));  
124.         }  
125. else if (acc.getBalance() < -2000) {  
126. "操作受限！");  
127.         }  
128.     }  
129. }  
130.   
131. //受限状态：具体状态类  
132. class RestrictedState extends AccountState {  
133. public RestrictedState(AccountState state) {  
134. this.acc = state.acc;  
135.     }  
136.       
137. public void deposit(double amount) {  
138.         acc.setBalance(acc.getBalance() + amount);  
139.         stateCheck();  
140.     }  
141.       
142. public void withdraw(double amount) {  
143. "帐号受限，取款失败");  
144.     }  
145.       
146. public void computeInterest() {  
147. "计算利息！");  
148.     }  
149.       
150. //状态转换  
151. public void stateCheck() {  
152. if(acc.getBalance() > 0) {  
153. new NormalState(this));  
154.         }  
155. else if(acc.getBalance() > -2000) {  
156. new OverdraftState(this));  
157.         }  
158.     }  
159. }  

       编写如下客户端测试代码：

1. public class Client {  
2. public static void main(String args[]) {  
3. new Account("段誉",0.0);  
4. 1000);  
5. 2000);  
6. 3000);  
7. 4000);  
8. 1000);  
9.         acc.computeInterest();  
10.     }  
11. }  

       编译并运行程序，输出结果如下：

4 共享状态

      在有些情况下，多个环境对象可能需要共享同一个状态，如果希望在系统中实现多个环境对象共享一个或多个状态对象，那么需要将这些状态对象定义为环境类的静态成员对象。

      下面通过一个简单实例来说明如何实现共享状态：

5所示：

图5 开关及其状态设计结构图

Switch代码如下所示：

1. public class Switch {  
2. private static State state,onState,offState; //定义三个静态的状态对象  
3. private String name;  
4.       
5. public Switch(String name) {  
6. this.name = name;  
7. new OnState();  
8. new OffState();  
9. this.state = onState;  
10.     }  
11.   
12. public void setState(State state) {  
13. this.state = state;  
14.     }  
15.   
16. public static State getState(String type) {  
17. if (type.equalsIgnoreCase("on")) {  
18. return onState;  
19.         }  
20. else {  
21. return offState;  
22.         }  
23.     }  
24.           
25. //打开开关  
26. public void on() {  
27.         System.out.print(name);  
28. this);  
29.     }  
30.       
31. //关闭开关  
32. public void off() {  
33.         System.out.print(name);  
34. this);  
35.     }  
36. }  

       抽象状态类如下代码所示：

1. public abstract class State {  
2. public abstract void on(Switch s);  
3. public abstract void off(Switch s);  
4. }  

       两个具体状态类如下代码所示：

1. //打开状态  
2. public class OnState extends State {  
3. public void on(Switch s) {  
4. "已经打开！");  
5.     }  
6.       
7. public void off(Switch s) {  
8. "关闭！");  
9. "off"));  
10.     }  
11. }  
12.   
13. //关闭状态  
14. class OffState extends State {  
15. public void on(Switch s) {  
16. "打开！");  
17. "on"));  
18.     }  
19.       
20. public void off(Switch s) {  
21. "已经关闭！");  
22.     }  
23. }  

       编写如下客户端代码进行测试：

1. public class Client {  
2. public static void main(String args[]) {  
3.         Switch s1,s2;  
4. new Switch("开关1");  
5. new Switch("开关2");  
6.           
7.         s1.on();  
8.         s2.on();  
9.         s1.off();  
10.         s2.off();  
11.         s2.on();  
12.         s1.on();      
13.     }  
14. }  

       输出结果如下：

       从输出结果可以得知两个开关共享相同的状态，如果第一个开关关闭，则第二个开关也将关闭，再次关闭时将输出“已经关闭”；打开时也将得到类似结果。

5 使用环境类实现状态转换

具体状态类可通过调用环境类Context的setState()方法进行状态的转换操作，也可以统一由环境类Context来实现状态的转换。此时，增加新的具体状态类可能需要修改其他具体状态类或者环境类的源代码，否则系统无法转换到新增状态。但是对于客户端来说，无须关心状态类，可以为环境类设置默认的状态类，而将状态的转换工作交给具体状态类或环境类来完成，具体的转换细节对于客户端而言是透明的。

stateCheck()方法，在该方法内部实现状态的转换，除此之外，我们还可以通过环境类来实现状态转换，环境类作为一个状态管理器，统一实现各种状态之间的转换操作。

       下面通过一个包含循环状态的简单实例来说明如何使用环境类实现状态转换：

NormalState、LargerState和LargestState来对应屏幕的三种状态，分别是正常状态、二倍放大状态和四倍放大状态，屏幕类Screen充当环境类，其结构如图6所示：

图6 屏幕放大镜工具结构图

       本实例核心代码如下所示：

1. //屏幕类  
2. public class Screen {  
3. //枚举所有的状态，currentState表示当前状态  
4. private State currentState, normalState, largerState, largestState;  
5.   
6. public Screen() {  
7. this.normalState = new NormalState(); //创建正常状态对象  
8. this.largerState = new LargerState(); //创建二倍放大状态对象  
9. this.largestState = new LargestState(); //创建四倍放大状态对象  
10. this.currentState = normalState; //设置初始状态  
11. this.currentState.display();  
12.     }  
13.       
14. public void setState(State state) {  
15. this.currentState = state;  
16.     }  
17.       
18. //单击事件处理方法，封转了对状态类中业务方法的调用和状态的转换  
19. public void onClick() {  
20. if (this.currentState == normalState) {  
21. this.setState(largerState);  
22. this.currentState.display();  
23.         }  
24. else if (this.currentState == largerState) {  
25. this.setState(largestState);  
26. this.currentState.display();  
27.         }  
28. else if (this.currentState == largestState) {  
29. this.setState(normalState);  
30. this.currentState.display();  
31.         }  
32.     }  
33. }  
34.   
35. //抽象状态类  
36. abstract class State {  
37. public abstract void display();  
38. }  
39.   
40. //正常状态类  
41. class NormalState extends State{  
42. public void display() {  
43. "正常大小！");  
44.     }  
45. }  
46.   
47. //二倍状态类  
48. class LargerState extends State{  
49. public void display() {  
50. "二倍大小！");  
51.     }  
52. }  
53.   
54. //四倍状态类  
55. class LargestState extends State{  
56. public void display() {  
57. "四倍大小！");  
58.     }  
59. }  

Screen来实现，此时，环境类充当了状态管理器角色。如果需要增加新的状态，例如“八倍状态类”，需要修改环境类，这在一定程度上违背了“开闭原则”，但对其他状态类没有任何影响。

       编写如下客户端代码进行测试：

1. public class Client {  
2. public static void main(String args[]) {  
3. new Screen();  
4.         screen.onClick();  
5.         screen.onClick();  
6.         screen.onClick();  
7.     }  
8. }  

       输出结果如下：