从状态模式看“大神”和“菜鸟”的区别

大话设计模式》中讲状态模式这一节名字叫做“无尽加班何时休-状态模式”。菜鸟由于编程经验不足，解决问题的能力不够而不得不牺牲时间去不断的写代码结果还是反复出错。而大神每次都能深入到问题的根源运用自己的思想去写代码，每个问题都完美的解决。

     加班的菜鸟一天各个时间段状态都不一样，从开始的精神百倍到越来越疲惫。自己写出的代码不断带来问题。

     代码是程序员思维智慧的结晶，菜鸟”程序员没有将自己的思维融入代码写出来的是这样的：

[csharp]  view plain copy

1. class Program  
2.     {  
3.   
4.         static void Main(string[] args)  
5.         {  
6.             Work emergencyProjects = new Work();  
7.             emergencyProjects.Hour = 9;  
8.             emergencyProjects.WriteProgram();  
9.             emergencyProjects.Hour = 10;  
10.             emergencyProjects.WriteProgram();  
11.             emergencyProjects.Hour = 12;  
12.             emergencyProjects.WriteProgram();  
13.             emergencyProjects.Hour = 13;  
14.             emergencyProjects.WriteProgram();  
15.             emergencyProjects.Hour = 14;  
16.             emergencyProjects.WriteProgram();  
17.             emergencyProjects.Hour = 17;  
18.   
19.             emergencyProjects.TaskFinished = false;  
20.   
21.             emergencyProjects.WriteProgram();  
22.             emergencyProjects.Hour = 19;  
23.             emergencyProjects.WriteProgram();  
24.             emergencyProjects.Hour = 22;  
25.             emergencyProjects.WriteProgram();  
26.   
27.             Console.Read();  
28.         }  
29.   
30.     }  
31.     class Work  
32.     {  
33.         private int hour;  
34.         public int Hour  
35.         {  
36.             get { return hour; }  
37.             set { hour = value; }  
38.         }  
39.         private bool finish = false;  
40.         public bool TaskFinished  
41.         {  
42.             get { return finish; }  
43.             set { finish = value; }  
44.         }  
45.   
46.         public void WriteProgram()  
47.         {  
48.             if (Hour < 12)  
49.             {  
50.                 Console.WriteLine("当前时间：{0}点 上午工作，精神百倍", Hour);  
51.   
52.             }  
53.             else if (Hour < 13)  
54.             {  
55.                 Console.WriteLine("当前时间{0}点 饿了，午饭；犯困，午休。", Hour);  
56.             }  
57.             else if (Hour < 17)  
58.             {  
59.                 Console.WriteLine("当前时间：{0}点 下午状态不错，继续努力", Hour);  
60.             }  
61.             else  
62.             {  
63.                 if (finish)  
64.                 {  
65.                     Console.WriteLine("当前时间{0}点 下班回家了", Hour);  
66.                 }  
67.                 else  
68.                 {  
69.                     if (Hour < 12)  
70.                     {  
71.                         Console.WriteLine("当前时间{0}点 加班哦，疲累", Hour);  
72.                     }  
73.                     else  
74.                     {  
75.                         Console.WriteLine("当前时间{0}点 不行了，睡着了。", Hour);  
76.                     }  
77.                 }  
78.             }  
79.         }  
80.   
81.     }  

        这样的代码方法过长，里面判断分支太多如果要增加一些情况会改动很多的代码，给维护带来很大的风险。

     运用状态模式：

[csharp]  view plain copy

1. //工作类，现在没有了过长的分支判断语句  
2.    public class Work  
3.    {  
4.        private State current;  
5.        public Work ()  
6.        {  
7.            current = new ForenoonState();//初始化工作状态为上午，即9点  
8.        }          
9.          
10.        //"钟点"属性，状态转换依据  
11.        private double  hour;  
12.        public double Hour  
13.        {  
14.            get { return hour; }  
15.            set { hour = value; }              
16.        }  
17.        //“任务完成”属性，是否下班的依据  
18.        private bool finish = false;  
19.        public bool TaskFinished  
20.        {  
21.            get { return finish; }  
22.            set { finish = value; }  
23.        }  
24.        public void SetState(State s)  
25.        {  
26.            current = s;  
27.        }  
28.        public void WriteProgram()  
29.        {  
30.            current.WriteProgram(this);  
31.        }  
32.    }  
33.   
34.    //抽象状态  
35.    public abstract class State  
36.    {  
37.        public abstract void WriteProgram (Work w);  
38.    }  
39.   
40.    //上午工作状态  
41.    public class ForenoonState : State  
42.    {  
43.        public override void WriteProgram(Work w)  
44.        {  
45.            if (w.Hour < 12)  
46.            { Console.WriteLine("当前时间：{0}点 上午工作，精神百倍", w.Hour); }  
47.            else  
48.            {  
49.                w.SetState(new NoonState());  
50.                w.WriteProgram();                  
51.            }  
52.        }  
53.    }  
54.    // 中午工作状态  
55.    public class NoonState : State  
56.    {  
57.        public override void WriteProgram(Work w)  
58.        {  
59.            if (w.Hour < 13)  
60.            {  
61.                Console.WriteLine("当前时间：{0}点 饿了，午饭；犯困，午休。", w.Hour);  
62.            }  
63.            else  
64.            {  
65.                w.SetState(new AfternoonState());  
66.                w.WriteProgram();  
67.            }  
68.        }  
69.    }  
70.    //下午工作状态  
71.    public class AfternoonState : State  
72.    {  
73.        public override void WriteProgram(Work w)  
74.        {  
75.            if (w.Hour < 17)  
76.            {  
77.                Console.WriteLine("当前时间：{0}点 下午状态不错，继续努力", w.Hour);  
78.            }  
79.            else  
80.            {  
81.                w.SetState(new EveningState());  
82.                w.WriteProgram();  
83.            }  
84.        }  
85.    }  
86.    //晚间工作状态  
87.    public class EveningState : State  
88.    {  
89.        public override void WriteProgram(Work w)  
90.        {  
91.            if (w.TaskFinished )  
92.            {  
93.                w.SetState(new RestState());  
94.                w.WriteProgram();  
95.            }  
96.            else  
97.            {  
98.                if (w.Hour < 21)  
99.                {  
100.                    Console.WriteLine("当前时间：{0}点 加班哦，疲累", w.Hour);  
101.                }  
102.                else  
103.                {  
104.                    w.SetState(new SleepingState());  
105.                    w.WriteProgram();  
106.                }  
107.            }  
108.        }  
109.    }  
110.    //睡眠状态  
111.    public class SleepingState : State  
112.    {  
113.        public override void WriteProgram(Work w)  
114.        {  
115.            Console .WriteLine ("当前时间：{0}点 不行了，睡着",w.Hour );  
116.        }  
117.    }  
118.    //下班休息状态  
119.    public class RestState : State  
120.    {  
121.        public override void WriteProgram(Work w)  
122.        {  
123.            Console.WriteLine("当前时间：{0}点 下班回家了", w.Hour);  
124.        }  
125.    }  

[csharp]  view plain copy

1. 客户端同上。  

         运用状态模式将特定状态相关的行为局部化，并且将不同状态的行为分割开来。把各种状态转移逻辑分布到子类之间来减少依赖。  这样的程序是有灵活性的。

      通往“大神”的路上……