java设计模式-State（状态）模式

state定义 
    不同的状态,不同的行为;或者说,每个状态有着相应的行为. 
    
    就像电风扇的开关，一档的上一个是关闭，关闭的上一个是五档，五档的上一个是四档，以此类推，而且五档的下一个是关闭，关闭的下一个是一档。那么在实际应用中，我们可能会这样做： 
     在上一档的方法中： 

Java代码  

1. if(level == 5){  
2.     level = 4;  
3. do something();  
4. }else if(level == 4){  
5.     level = 3;  
6. do something();  
7.   
8. } else if (level == 3){  
9.     level == 2;  
10. do something();  
11.   
12. }  

    在下一档的方法中： 

Java代码  

1. if(level == 1){  
2.     level = 2;  
3. do something();  
4.   
5. }else if(level == 2){  
6.     level = 3;  
7. do something();  
8.   
9. } else if (level == 3){  
10.     level == 4;  
11. do something();  
12.   
13. }  

    单一方向的切换还好点，双方向的切换就可以考虑使用state模式了 

     假设现在有一个开关，控制三种颜色的切换，blue，green，red，蓝色下一个绿色，绿色下一个红色，红色下一个是蓝色，也可以倒过来 

代码如下： 

Java代码  

1. package state;  
2.   
3. /* 
4.  * 状态操作接口，执行上一个下一个的操作,还可以获得当前的状态 
5.  * 当然在这可以既执行别的操作，比如开关拨到某个颜色的时候，颜色对应的灯亮 
6.  */  
7.   
8. public interface State {  
9.   
10.     public  void last(Context c);  
11.   
12.     public  void next(Context c);  
13.       
14.     public  String getState();  
15.   
16.   
17. }  

Java代码  

1. package state;  
2.   
3. /* 
4.  * 蓝色状态类，实现的接口的方法，通过状态管理器在上一个或者下一个方法中 
5.  * 设置改变后的状态 
6.  */  
7. public class BlueState implements State {  
8.   
9.     public String getState() {  
10.         // TODO Auto-generated method stub  
11.         return "blue";  
12.     }  
13.   
14.     public void last(Context c) {  
15.         c.setState(new GreenState());  
16.   
17.     }  
18.   
19.     public void next(Context c) {  
20.         c.setState(new RedState());  
21.   
22.     }  
23.   
24. }  

Java代码  

1. package state;  
2.   
3. /* 
4.  * 绿色状态类，实现的接口的方法，通过状态管理器在上一个或者下一个方法中 
5.  * 设置改变后的状态 
6.  */  
7. public class GreenState implements State {  
8.   
9.     public String getState() {  
10.           
11.         return "green";  
12.     }  
13.   
14.     public void last(Context c) {  
15.         c.setState(new RedState());  
16.   
17.     }  
18.   
19.     public void next(Context c) {  
20.     c.setState(new BlueState());  
21.   
22.     }  
23.   
24. }  

Java代码  

1.  package state;  
2. /* 
3.  * 红色状态类，实现的接口的方法，通过状态管理器在上一个或者下一个方法中 
4.  * 设置改变后的状态 
5.  */  
6.  public class RedState implements State {  
7.   
8. public String getState() {  
9.     return "red";  
10. }  
11.   
12. public void last(Context c) {  
13. c.setState(new BlueState());  
14.   
15. }  
16.   
17. public void next(Context c) {  
18.     c.setState(new GreenState());  
19.   
20. }  

Java代码  

1. package state;  
2.   
3. /* 
4.  * 状态管理器，设置初始状态，得到当前状态， 
5.  * 提供了两个操作，上一个的操作方法中，调用了当前状态的last方法，将状态管理器的状态更新 
6.  *                下一个的操作方法中，调用了当前状态的next方法，将状态管理器的状态更新 
7.  */  
8. public class Context {  
9.       
10.     private State state = null;  
11.   
12.     public State getState() {  
13.         return state;  
14.     }  
15.   
16.     public void setState(State state) {  
17.         this.state = state;  
18.     }  
19.       
20.     public void push(){  
21.           
22.         state.last(this);  
23.         System.out.println(state.getState());  
24.     }  
25.       
26.     public void pull(){  
27.           
28.         state.next(this);  
29.         System.out.println(state.getState());  
30.     }  
31.       
32.   
33. }  

Java代码  

1. package state;  
2. /* 
3.  * 测试类 
4.  */  
5. public class Test {  
6.   
7.     public static void main(String[] args) throws InterruptedException {  
8.         /* 
9.          * 创建一个状态管理器，设置初始状态为红色， 
10.          * 然后就可以执行状态管理器的last或者next方法 
11.          */  
12.         Context c = new Context();  
13.         State redsState = new RedState();         
14.         c.setState(redsState);  
15.             while (true){  
16.                 System.out.println("当前状态："+c.getState().getState());  
17.                 System.out.print("上一个状态: ");  
18.                  c.push();  
19.                  Thread.currentThread().sleep(2000);  
20.             }          
21.     }  
22.       
23. }  

 

    缺点也显而易见了，如果状态太多了，对应的状态类也会比较多的。。