JAVA状态模式2

原文链接： http://blog.csdn.net/janice0529/article/details/41054673

一、概述

    当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化。状态模式是一种对象行为型模式。

二、适用场景

    用于解决系统中复杂对象的多种状态转换以及不同状态下行为的封装问题。简单说就是处理对象的多种状态及其相互转换。

三、UML类图

    

四、参与者

1>、AbstractState(抽象状态类):

在抽象状态类中定义申明了不同状态下的行为抽象方法，而由子类(不同的状态子类)中实现不同的行为操作。

2>、ConcreteState(实现具体状态下行为的状态子类):

抽象状态类的子类，每一个子类实现一个与环境类(Context)的一个状态相关的行为，每一个具体的状态类对应环境的一种具体状态，不同的具体状态其行为有所不同。

3>、Context(拥有状态对象的环境类):

拥有状态属性，因环境的多样性，它可拥有不同的状态，且在不同状态下行为也不一样。在环境类中维护一个抽象的状态实例，这个实例定义当前环境的状态(setState()方法)，而将具体的状态行为分离出来由不同的状态子类去完成。

五、用例学习

1、抽象状态类：State.Java

[java] view plain copy

1. /** 
2.  * JAVA设计模式之 状态模式 
3.  * 抽象状态类 
4.  * @author  [e-mail] 
5.  * 
6.  */  
7. public abstract class State {  
8.     /** 
9.      * 状态行为抽象方法,由具体的状态子类去实现不同的行为逻辑 
10.      */  
11.     public abstract void Behavior();  
12.   
13. }  

2、具体状态子类A：ConcreteStateA.java

[java] view plain copy

1. /** 
2.  * 具体的状态子类A 
3.  * @author  [e-mail] 
4.  */  
5. public class ConcreteStateA extends State {  
6.   
7.     @Override  
8.     public void Behavior() {  
9.         // 状态A 的业务行为, 及当为该状态下时，能干什么   
10.         // 如：手机在未欠费停机状态下, 能正常拨打电话  
11.         System.out.println("手机在未欠费停机状态下, 能正常拨打电话");  
12.     }  
13.   
14. }  

3、具体状态子类B：ConcreteStateB.java

[java] view plain copy

1. /** 
2.  * 具体的状态子类B 
3.  * @author  [e-mail] 
4.  * 
5.  */  
6. public class ConcreteStateB extends State {  
7.   
8.     @Override  
9.     public void Behavior() {  
10.         // 状态B 的业务行为, 及当为该状态下时，能干什么  
11.         // 如：手机在欠费停机状态下, 不 能拨打电话  
12.         System.out.println("手机在欠费停机状态下, 不能拨打电话");  
13.     }  
14.   
15. }  

4、拥有状态对象的环境类：Context.java

[java] view plain copy

1. /** 
2.  * 环境/上下文类<br/> 
3.  * 拥有状态对象，且可以完成状态间的转换 [状态的改变/切换 在环境类中实现] 
4.  * @author  [e-mail] 
5.  * 
6.  */  
7. public class Context {  
8.     // 维护一个抽象状态对象的引用  
9.     private State state;  
10.       
11.     /* 
12.      * 模拟手机的话费属性<br/> 
13.      * 环境状态如下： 
14.      * 1>、当  bill >= 0.00$ : 状态正常   还能拨打电话  
15.      * 2>、当  bill < 0.00$ : 手机欠费   不能拨打电话 
16.      */  
17.     private double bill;  
18.       
19.     /** 
20.      * 环境处理函数，调用状态实例行为 完成业务逻辑<br/> 
21.      * 根据不同的状态实例引用  在不同状态下处理不同的行为 
22.      */  
23.     public void Handle(){  
24.         checkState();  
25.         state.Behavior();  
26.     }  
27.       
28.       
29.     /** 
30.      * 检查环境状态:状态的改变/切换 在环境类中实现 
31.      */  
32.     private void checkState(){  
33.         if(bill >= 0.00){  
34.             setState(new ConcreteStateA());  
35.         } else {  
36.             setState(new ConcreteStateB());  
37.         }  
38.     }  
39.       
40.       
41.     /** 
42.      * 设置环境状态<br/> 
43.      * 私有方法，目的是 让环境的状态由系统环境自身来控制/切换,外部使用者无需关心环境内部的状态 
44.      * @param state 
45.      */  
46.     private void setState(State state){  
47.         this.state = state;  
48.     }  
49.   
50.   
51.     public double getBill() {  
52.         return bill;  
53.     }  
54.   
55.     public void setBill(double bill) {  
56.         this.bill = bill;  
57.     }  
58. }  

5、测试客户端调用类：Client.java

[java] view plain copy

1. public class Client {  
2.   
3.     public static void main(String[] args) {  
4.         Context context = new Context();  
5.         context.setBill(5.50);  
6.         System.out.println("当前话费余额：" + context.getBill() + "$");  
7.         context.Handle();  
8.           
9.         context.setBill(-1.50);  
10.         System.out.println("当前话费余额：" + context.getBill() + "$");  
11.         context.Handle();  
12.           
13.         context.setBill(50.00);  
14.         System.out.println("当前话费余额：" + context.getBill() + "$");  
15.         context.Handle();  
16.     }  
17. }  

6、程序运行结果：

[plain] view plain copy

1. 当前话费余额：5.5$  
2. 手机在未欠费停机状态下, 能正常拨打电话  
3. 当前话费余额：-1.5$  
4. 手机在欠费停机状态下, 不能拨打电话  
5. 当前话费余额：50.0$  
6. 手机在未欠费停机状态下, 能正常拨打电话  

六、扩展

    状态模式中 关于状态的切换有两种不同的实现方式

    方式一：状态的改变/切换  在环境类中实现。  如上面的用例代码Context类中的checkState()方法。

[java] view plain copy

1. /** 
2.      * 检查环境状态:状态的改变/切换 在环境类中实现 
3.      */  
4.     private void checkState(){  
5.         if(bill >= 0.00){  
6.             setState(new ConcreteStateA());  
7.         } else {  
8.             setState(new ConcreteStateB());  
9.         }  
10.     }  

    方式二：状态的改变/切换  在具体的状态子类中实现。

        实现步骤如下：

        1> 在环境类Context类中 初始化一个状态实例对象，并将环境Context对象作为子类状态的构造参数传递到具体的状态子类实例中。

       如在Context.java类中：

[html] view plain copy

1. // 设置初始状态  
2. this.state = new ConcreteStateA(this);  

        2> 在具体的子类状态类中根据构造进来的context对象，通过调用context对象的属性值进行业务逻辑判断 进行状态的检查和切换。

        如在 具体的状态子类ConcreteStateA.java类中：

[java] view plain copy

1. /** 
2.  * 具体的状态子类A 
3.  * @author  [e-mail] 
4.  */  
5. public class ConcreteStateA extends State {  
6.     private Context ctx;  
7.       
8.     public ConcreteStateA(Context context){  
9.         ctx = context;  
10.     }  
11.       
12.     @Override  
13.     public void Behavior() {  
14.         // 状态A 的业务行为, 及当为该状态下时，能干什么   
15.         // 如：手机在未欠费停机状态下, 能正常拨打电话  
16.         System.out.println("手机在未欠费停机状态下, 能正常拨打电话");  
17.         checkState();  
18.           
19.     }  
20.   
21.     /** 
22.      * 检查状态 是否需要进行状态的转换<br/> 
23.      * 状态的切换由具体状态子类中实现 
24.      */  
25.     private void checkState(){  
26.         if (ctx.getBill() < 0.00) {  
27.             ctx.setState(new ConcreteStateB(ctx));  
28.         }  
29.     }  
30. }