12 状态模式

状态模式（State）定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

UML类图：

状态模式适用于要转换很多业务状态的场景。比如，Head First举的糖果机例子，

糖果机有“没有投币”、“有投币”、“售出糖果”、“糖果售罄”四种状态，并且有四种动作：“投入硬币”、“返回硬币”、“转动曲柄”、“发放糖果”。四种动作与四种状态之间的关系比较复杂，但上图可以清晰地表达出这种关系。

如果按照面向过程的实现方法，要表达出这种关系，需要一大堆的if else分支（4*4=16个），更麻烦的是，如果有新的状态加入，要修改的地方太多，违背了开放-封闭原则。

而采用状态模式可以部分地解决这个问题。

状态模式将每个状态封装成一个类，四种动作便成了类的四个方法，不同的类对这些方法有不同的实现，实现了状态类之间的自动切换。看起来很有《失控》中，那只用去中心化思维制造的机器昆虫，没有大脑，只为每只脚设定了动作规则，就可以完美运行。

代码如下：

先是规定了四种动作的接口：

    interface State
    {
        void InsertQuarter();
        void EjectQuarter();
        void TurnQuarter();
        void Dispense();
    }

自带逻辑的四种状态如下(五种状态，这里多了赢家状态，赢家状态会一次吐出两颗糖果)：

    class NoQuarterState:State
    {
        GumballMachine gumballMachine;
        public NoQuarterState(GumballMachine g)
        {
            gumballMachine = g;
        }
        public void InsertQuarter()
        {
            Console.WriteLine("You inserted a quarter");
            gumballMachine.SetState(gumballMachine.GetHasQuarterState());
        }

        public void EjectQuarter()
        {
            Console.WriteLine("You haven't inserted a quarter");
        }

        public void TurnQuarter()
        {
            Console.WriteLine("You turned,but there's no quarter");
        }

        public void Dispense()
        {
            Console.WriteLine("You need to pay first");
        }
    }

//
class HasQuarterState : State
    {
        Random randomWinner = new Random(DateTime.Now.Millisecond);
        GumballMachine gumballMachine;
        public HasQuarterState(GumballMachine g)
        {
            gumballMachine = g;
        }
        public void InsertQuarter()
        {
            Console.WriteLine("You can't insert another quarter");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("Quarter returned");
        }

        public void TurnQuarter()
        {

            Console.WriteLine("You turned");
            int randomNum = randomWinner.Next();
            if ((randomNum % 2 == 0) && (gumballMachine.GetCurrentCount() > 0))
            {
                gumballMachine.SetState(gumballMachine.GetWinnerState());
            }
            else
            {
                gumballMachine.SetState(gumballMachine.GetSoldState());
            }
            
        }

        public void Dispense()
        {
            Console.WriteLine("No gumball dispensed");
        }
    }
//
class SoldState : State
    {
        GumballMachine gumballMachine;
        public SoldState(GumballMachine g)
        {
            gumballMachine = g;
        }
        public void InsertQuarter()
        {
            Console.WriteLine("Please wait,we're already giving you a gumball");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("Sorry, you already turned the crank");
        }

        public void TurnQuarter()
        {
            Console.WriteLine("Turning twice doesn't get you another gumball");
        }

        public void Dispense()
        {
            gumballMachine.ReleaseBall();
            if (gumballMachine.GetCurrentCount() > 0)
            {
                gumballMachine.SetState(gumballMachine.GetNoQuarterState());
            }
            else
            {
                Console.WriteLine("Oops,out of gumballs");
                gumballMachine.SetState(gumballMachine.GetSoldOutState());
            }
        }
    }
//
class SoldOutState:State
    {
        GumballMachine gumballMachine;
        public SoldOutState(GumballMachine g)
        {
            gumballMachine = g;
        }
        public void InsertQuarter()
        {
            Console.WriteLine("There is not gumballs");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("You haven't inject a gumball");
        }

        public void TurnQuarter()
        {
            Console.WriteLine("Be quiet");
        }

        public void Dispense()
        {
            Console.WriteLine("No quarter anymore");
        }
    }

糖果机代码如下：

class GumballMachine
    {
        State soldOutState;
        State noQuarterState;
        State hasQuarterState;
        State soldState;
        State winnerState;
        State state;
        int count = 0;
        public GumballMachine(int numberGumballs)
        {
            soldOutState = new SoldOutState(this);
            noQuarterState = new NoQuarterState(this);
            hasQuarterState = new HasQuarterState(this);
            soldState = new SoldState(this);
            winnerState = new WinnerState(this);
            this.count = numberGumballs;
            if (numberGumballs > 0)
            {
                state = noQuarterState;
            }
            else
            {
                state = soldOutState;
            }
        }

        public void InsertQuarter()
        {
            state.InsertQuarter();
        }
        public void EjectQuarter()
        {
            state.EjectQuarter();
        }
        public void TurnCrank()
        {
            state.TurnQuarter();
            state.Dispense();
        }
        public void SetState(State s)
        {
            state = s;
        }
        public void ReleaseBall()
        {
            Console.WriteLine("A gumball comes rolling out the slot");
            if (count != 0) count--;
        }

        public State GetSoldOutState()
        {
            return soldOutState;
        }
        public State GetNoQuarterState()
        {
            return noQuarterState;
        }
        public State GetHasQuarterState()
        {
            return hasQuarterState;
        }
        public State GetSoldState()
        {
            return soldState;
        }
        public State GetWinnerState()
        {
            return winnerState;
        }
        public int GetCurrentCount()
        {
            return count;
        }
    }

这里状态的转换由State类内部控制，但有可由Context就是这儿的Main函数中直接控制，可根据具体需求决定采用哪种方式。

使用状态模式通常会导致设计中类的数目大量增加。但相比很多if else分支来说，还是可取的，而且这些类并不对外可见。

状态模式与策略模式的区别：

两者的类图相同，但区别在于意图不同。

状态模式允许Context随着状态的改变而改变行为，但策略模式则用行为或算法来配置Context类。状态模式的状态变化逻辑已经内化，但策略模式使用哪种算法，可由外部决定。