状态模式（State）

http://blog.csdn.net/fly_yr/article/details/8568651

 状态模式（State），当一个对象的内在状态改变时，允许改变其行为，这个对象看起来好像改变了其类。状态模式主要解决的是当控制一个对象的状态转换条件表达式过于复杂时的情况。把状态的判断逻辑转移到不同状态的一系列类中，可以把复杂的判断逻辑简化。

状态模式UML类图：

       分析：由上图可知（1）State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为；（2）ConcreteState类，具体状态，每一个子类实现一个与Context的一个特定状态相关的行为；（3）Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态

状态模式实现：

[csharp] view plain copy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace State  
7. {  
8.      
9.     /* 
10.      * State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为 
11.      */  
12.     abstract class State  
13.     {  
14.         public abstract void Handle(Context context);  
15.     }  
16.     /* 
17.      * ConcreteState类，具体状态，每一个子类实现一个与Context的一个特定状态相关的行为。 
18.      */  
19.     class ConcreteStateA : State  
20.     {  
21.         public override void Handle(Context context)  
22.         {  
23.             context.setState(new ConcreteStateB());//假设ConcreteStateA的下一个状态是ConcreteStateB  
24.             //throw new NotImplementedException();  
25.         }  
26.     }  
27.   
28.   
29.     class ConcreteStateB : State  
30.     {  
31.         public override void Handle(Context context)  
32.         {  
33.             context.setState(new ConcreteStateA());//假设ConcreteStateB的下一个状态是ConcreteStateA  
34.             //throw new NotImplementedException();  
35.         }  
36.     }  
37.     /* 
38.      * Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态 
39.      */  
40.     class Context  
41.     {  
42.         private State state;  
43.   
44.         public Context(State state)  
45.         {  
46.             this.state = state;  
47.         }  
48.   
49.         public State getState()  
50.         {  
51.             return this.state;  
52.         }  
53.   
54.         public void setState(State state)  
55.         {  
56.             this.state = state;  
57.             Console.WriteLine("当前状态："+this.state.GetType().Name);  
58.         }  
59.   
60.         public void Request()  
61.         {  
62.             this.state.Handle(this);  
63.         }  
64.     }  
65.   
66. }  

客户端：

[csharp] view plain copy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace State  
7. {  
8.     //客户端代码  
9.     class Program  
10.     {  
11.         static void Main(string[] args)  
12.         {  
13.             Context context = new Context(new ConcreteStateA());  
14.   
15.             context.Request();  
16.             context.Request();  
17.             context.Request();  
18.             context.Request();  
19.   
20.             Console.Read();  
21.         }  
22.     }  
23. }  

状态模式总结：

       （1）状态模式的好处就是将于特定状态相关的行为局部化，并且将不同状态的行为分割开来。意即，将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类可以很容易地增加新的状态和转换。

       （2）这样做的目的是为了消除庞大的条件分支语句，大的分支判断会使得它们难以修改和扩展，状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。

       （3）当一个对象的行为取决于它们的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式。

      

 状态模式案例—工作状态

[csharp] view plain copy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace StateExample  
7. {  
8.     /* 
9.      * 抽象状态类 
10.      */  
11.     abstract class State  
12.     {  
13.         public abstract void writeProgram(Work work);  
14.     }  
15.   
16.     /* 
17.      * 具状态类 
18.      */  
19.     class ForenoonState : State  
20.     {  
21.         public override void writeProgram(Work work)  
22.         {  
23.             if (work.getHour() < 12)  
24.             {  
25.                 Console.WriteLine("当前时间{0}，上午状态，精神百倍！", work.getHour());  
26.             }  
27.             else  
28.             {  
29.                 work.setState(new NoonState());  
30.                 work.writeProgram();  
31.             }  
32.             //throw new NotImplementedException();  
33.         }  
34.     }  
35.   
36.     class NoonState : State  
37.     {  
38.         public override void writeProgram(Work work)  
39.         {  
40.             if (work.getHour() < 13)  
41.             {  
42.                 Console.WriteLine("当前时间{0}，午饭时间！", work.getHour());  
43.             }  
44.             else  
45.             {  
46.                 work.setState(new AfterNoonState());  
47.                 work.writeProgram();  
48.             }  
49.             //throw new NotImplementedException();  
50.         }  
51.     }  
52.   
53.     class AfterNoonState : State  
54.     {  
55.         public override void writeProgram(Work work)  
56.         {  
57.             if (work.getHour() < 17)  
58.             {  
59.                 Console.WriteLine("当前时间{0}，下午状态，继续工作！", work.getHour());  
60.             }  
61.             else  
62.             {  
63.                 work.setState(new EveningState());  
64.                 work.writeProgram();  
65.             }  
66.             //throw new NotImplementedException();  
67.         }  
68.     }  
69.   
70.     class EveningState : State  
71.     {  
72.         public override void writeProgram(Work work)  
73.         {  
74.             if (work.getIsFinish())  
75.             {  
76.                 work.setState(new RestState());  
77.                 work.writeProgram();  
78.             }  
79.             else  
80.             {  
81.                 if (work.getHour() < 21)  
82.                 {  
83.                     Console.WriteLine("当前时间{0},加班状态，疲惫！", work.getHour());  
84.                 }  
85.                 else  
86.                 {  
87.                     work.setState(new SleepState());  
88.                     work.writeProgram();  
89.                 }  
90.             }  
91.             //throw new NotImplementedException();  
92.         }  
93.     }  
94.   
95.     class RestState : State  
96.     {  
97.         public override void writeProgram(Work work)  
98.         {  
99.             Console.WriteLine("当前时间{0},完成工作，下班回家！",work.getHour());  
100.             //throw new NotImplementedException();  
101.         }  
102.     }  
103.   
104.     class SleepState : State  
105.     {  
106.         public override void writeProgram(Work work)  
107.         {  
108.             Console.WriteLine("当前时间{0},睡觉状态！", work.getHour());  
109.             //throw new NotImplementedException();  
110.         }  
111.     }  
112.     /* 
113.      * 工作类 
114.      */  
115.     class Work  
116.     {  
117.         private double hour;  
118.         private State state;  
119.         private bool isFinish;  
120.   
121.         public Work(State state)  
122.         {  
123.             this.state = state;  
124.         }  
125.   
126.         public State getState()  
127.         {  
128.             return this.state;  
129.         }  
130.         public void setState(State state)  
131.         {  
132.             this.state = state;  
133.         }  
134.   
135.         public double getHour()  
136.         {  
137.             return this.hour;  
138.         }  
139.         public void setHour(double hour)  
140.         {  
141.             this.hour = hour;  
142.         }  
143.         public bool getIsFinish()  
144.         {  
145.             return this.isFinish;  
146.         }  
147.         public void setIsFinish(bool b)  
148.         {  
149.             this.isFinish = b;  
150.         }  
151.   
152.         public void writeProgram()  
153.         {  
154.             this.state.writeProgram(this);  
155.         }  
156.   
157.     }  
158. }  

客户端：

[csharp] view plain copy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace StateExample  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             Work work = new Work(new ForenoonState());  
13.             work.setHour(9);  
14.             work.writeProgram();  
15.             work.setHour(10);  
16.             work.writeProgram();  
17.             work.setHour(12);  
18.             work.writeProgram();  
19.             work.setHour(13);  
20.             work.writeProgram();  
21.             work.setHour(15);  
22.             work.writeProgram();  
23.             work.setHour(17);  
24.             work.writeProgram();  
25.   
26.             work.setIsFinish(false);  
27.             work.setHour(19);  
28.             work.writeProgram();  
29.             work.setHour(21);  
30.             work.writeProgram();  
31.             work.setHour(22);  
32.             work.writeProgram();  
33.   
34.             Console.Read();  
35.         }  
36.     }  
37. }  

运行结果：