21.State状态（行为型模式）

一：动机（Motivation）

<1>在软件构建过程中，某些对象的状态如果改变，其行为也会随之而发生变化，比如文档处于只读状态，其支持的行为和读写状态支持的行为就可能完全不同。

<2>如何在运行时根据对象的状态来透明地更改对象的行为？而不会为对象操作和状态转化之间引入紧耦合？

二：意图（Intent）

允许一个对象在其内部状态改变时改变它的行为。从而使对象看起来似乎修改了其行为。
——《设计模式》GoF

三：结构（Structure）

四：结构详解

五：生活中的例子

情人节里，要过节。过节时要：庆祝节日：
单身状态下：单身情歌
热恋状态下：花前月下
失恋状态下：对酒当歌几多愁

六：实现

namespace Test
{
    public abstract class 节日状态
    {
        public abstract void 庆祝节日();  //Handle()
    }

    public class 单身状态 : 节日状态  //ConcreteState
    {
        public override void 庆祝节日()
        {
            Console.WriteLine("单身情歌，没有情人的情人节：(~~~~~)");
        }
    }

    public class 热恋状态 : 节日状态  //ConcreteState
    {
        public override void 庆祝节日()
        {
            Console.WriteLine("花好月圆，花前月下，生活真美好：(~~~~~)");
        }
    }

    public class 失恋状态 : 节日状态
    {
        public override void 庆祝节日()
        {
            Console.WriteLine("对酒当歌几多愁，恰似一江春水向东流：(~~~~~)");
        }
    }

    /// 

    /// Context
    /// 
    public class 情人节
    {
        private 节日状态 state = new 单身状态();
        public 节日状态 状态
        {
            get { return state; }
            set { state = value; }
        }

        /// 

        /// Request();
        /// 
        public void 过节()
        {
            this.state.庆祝节日();
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            情人节 loverday = new 情人节();

            Console.WriteLine("\n第一年的情人节:");
            loverday.状态 = new 单身状态();
            loverday.过节();

            Console.WriteLine("\n第二年的情人节:");
            loverday.状态 = new 热恋状态();
            loverday.过节();

            Console.WriteLine("\n第三年的情人节:");
            loverday.状态 = new 失恋状态();
            loverday.过节();

            Console.ReadLine();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

实现结果

七：工作实现

namespace Test
{
    public abstract class BodyState
    {
        public abstract void Work();   
    }

    public class GoodState : BodyState
    {
        public override void Work()
        {
            Console.WriteLine("精力充沛地工作");
        }
    }

    public class ColdState : BodyState
    {
        public override void Work()
        {

            Console.WriteLine("打喷嚏+咳嗽地工作");
        }
    }

    public enum State
    {
        Good,
        Cold
    }

    public class Teacher
    {
        private Dictionary<State, BodyState> states = new Dictionary<State, BodyState>();
        public Teacher()
        {
            this.states.Add(State.Good, new GoodState());
            this.states.Add(State.Cold, new ColdState());
        }

        public void Teach(State state)
        {
            this.states[state].Work();
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            Teacher teacher = new Teacher();
            teacher.Teach(State.Good);
            Console.WriteLine("-----------");
            teacher.Teach(State.Cold);
            Console.ReadLine();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

八：适用性

<1>一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。

<2>一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常，有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

九：总结

<1>State模式将所有与一个特定状态相关的行为都放入一个State的子类对象中，在对象状态切换时，切换相应的对象；但同时维持State的接口，这样实现了具体操作与状态转换之间的解耦。

<2>为不同的状态引入不同的对象使得状态转换变得更加明确，而且可以保证不会出现状态不一致的情况，因为转换是原子性的——即要么彻底转换过来，要么不转换。

<3>如果State对象没有实例变量，那么各个上下文可以共享同一个State对象，从而节省对象开销。