设计模式之 -- 状态模式(State)

　  状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。当控制一个对象的状态转换条件分支语句（if...else或switch...case）过于复杂时，可以此模式将状态的判断逻辑转移到不同状态的一系列类中，将复杂的逻辑简单化，便于阅读与维护。

概述

1、为什么要使用状态模式？

　  在软件开发过程中，应用程序可能会根据不同的条件作出不同的行为。常见的解决办法是先分析所有条件，通过大量的条件分支语句（if...else或switch...case）指定应用程序在不同条件下作出的不同行为。但是，每当增加一个条件时，就可能修改大量的条件分支语句，使得分支代码越来越复杂，代码的可读性、扩展性、可维护性也会越来越差，这时候就该状态模式粉墨登场了。

2、解决原理

　  状态模式将大量的判断逻辑转移到表示不同状态的一系列中，从而消除了原先复杂的条件分支语句，降低了判断逻辑的复杂度。

3、状态模式适用的两种情况

　  ① 一个对象的行为取决于它的状态，并且他必须在运行时刻根据状态改变它的行为；

　  ② 一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示；

4、结构

　  状态模式的UML类图如图1所示：

图1 状态模式的UML类图

　  由图可知：

　  ① State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为；

　  ② ConcreteState类，具体状态，每一个子类实现一个与Context的一个特定状态相关的行为；

　  ③ Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态；

　  实现代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace State
{
    /*
     * State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为
     */
    abstract class State
    {
        public abstract void Handle(Context context);
    }
    
    class ConcreteStateA : State
    {
        public override void Handle(Context context)
        {
            //这里写状态A的处理代码
            //...
            
            //假设ConcreteStateA的下一个状态是ConcreteStateB
            //此处状态定义可以在状态子类中指定，也可以在外部指定
            context.setState(new ConcreteStateB()); 
        }
    }

    class ConcreteStateB : State
    {
        public override void Handle(Context context)
        {
            //这里写状态B的处理代码
            //...
            
            //假假设ConcreteStateB的下一个状态是ConcreteStateA
            //此处状态定义可以在状态子类中指定，也可以在外部指定
            context.setState(new ConcreteStateA());
        }
    }
    /*
     * Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态
     */
    class Context
    {
        private State state;

        public Context(State state)
        {
            this.state = state;
        }

        public State getState()
        {
            return this.state;
        }

        public void setState(State state)
        {
            this.state = state;
            Console.WriteLine("当前状态："+this.state.GetType().Name);
        }
        
        //调用子类的对应方法
        public void Request()
        {
            this.state.Handle(this);
        }
    }
}

5、状态模式带来的优点与效果

　  ① 使得程序逻辑更加清晰、易维护。使用状态模式消除了大量的条件分支语句，将特定的状态相关的行为都放入一个State子类对象中，由于所有与状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类可以很容易地增加新的状态和转换；

　  ② 它使得状态转换显示化。通过State对象表示不同的程序状态，比通过内部数据值来表示更加明确。而且数据转换状态有可能操作多个变量，而State对象转换只需更改状态实例，是一个原子操作，更加方便；

　  ③ State对象可以被共享。不同Context对象可以共享一个State对象，这是使用内部数据变量表示状态很难实现的；

　  此外，状态模式实现较为复杂，同时也会大大增加系统类和对象个数，建议在合适条件下引用。

从糖果机实例理解状态模式

　  在著名的《Head First设计模式》有关状态模式的一节中提到一个经典的糖果机设计问题，其状态图如下图所示：

图2 糖果机设计状态图

　  在此糖果机状态图，我们可以看出存在有四种状态和四种动作，这四种动作分别为：“投入25分钱”、“退回25分钱”、“转动曲柄”和“发放糖果”。如果糖果工程师让你来设计这个程序，那么作为一个聪明的程序员，你会怎么设计呢？

　  首先，我们会用一个枚举来表示不同的状态，分别代表：售罄状态、售出状态、没有25分钱状态、有25分钱状态。

private enum State {
    SOLD_OUT, SOLD, NO_QUARTER, HAS_QUARTER
}

　  然后在糖果机类体内定义一个内部状态变量state，用于记录糖果机当前所处的不同状态。然后在上述四种不同的动作方法内，根据此内部状态state的当前值来做出不同的处理。很快，糖果机很快就设计好了，代码如下：

package state.candymachine;

public class CandyMachine{
    
    //四种状态，分别代表：售罄状态、售出状态、没有25分钱状态、有25分钱状态
    private enum State {
        SOLD_OUT, SOLD, NO_QUARTER, HAS_QUARTER
    }

    private State state = State.NO_QUARTER;
    private int candyNums = 0;

    public CandyMachine(int candyNums) {
        this.candyNums = candyNums;
        if (candyNums > 0) {
            this.state = State.NO_QUARTER;
        } else {
            this.state = State.SOLD_OUT;
        }
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
        switch(this.state){
            case SOLD:
                System.out.println("糖果已经为您准备好，请点击售出糖果按钮..");
                break;
            case SOLD_OUT:
                System.out.println("本糖果机所有糖果已经售罄，尽情下次光临哦~~~");
                break;
            case NO_QUARTER:
                System.out.println("机器已经准备完毕，请您投入25分钱购买糖果~~~");
                break;
            case HAS_QUARTER:
                System.out.println("请您选择操作：退回25分钱 or 转动曲柄....");
                break;
        }
    }

    public int getCandyNums() {
        return candyNums;
    }

    public void setCandyNums(int candyNums) {
        this.candyNums = candyNums;
    }

    public void trunCrank() {
        if (state == State.HAS_QUARTER) {
            System.out.println("曲柄已经开始转动，您的糖果即将出炉,尽请稍候~~~");
            setState(State.SOLD);
        } else {
            System.out.println("无法转动曲柄，您还未投入25分钱呢");
        }
    }

    public void dispenseCandy() {
        if (state == State.SOLD) {
            System.out.println("发放糖果1颗，尽情享受吧...");
            this.candyNums = this.candyNums - 1;
            if (this.candyNums > 0) {
                setState(State.NO_QUARTER);
            } else {
                setState(State.SOLD_OUT);
            }
        }else{
            System.out.println("无法发放糖果，请先转动曲柄");
        }
    }

    public void insertQuarter() {
        if(state == State.NO_QUARTER){
            System.out.println("成功投入25分钱，您的糖果已经在等您了哦~~");
            setState(State.HAS_QUARTER);
        }else{
            System.out.println("无法投入25分钱，机器中已经有25分钱了");
        }
    }
    
     public void ejectQuarter(){
         if(state == State.HAS_QUARTER){
             System.out.println("您的25分钱已经退回，欢迎下次光临~~~");
            setState(State.NO_QUARTER);
         }else{
             System.out.println("无法退回25分钱，您还未投入钱呢");
         }
     }

}

　  现在我们来测试它是否能正常工作：

package state.candymachine;

import java.util.Scanner;

public class MachineTest {

    public static void main(String[] args) {
        CandyMachine machine = new CandyMachine(3);
        while (machine.getCandyNums() > 0) {
            System.out.println("当前糖果机还剩" + machine.getCandyNums() + "颗糖果");
            System.out.println("请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果");
            Scanner sc = new Scanner(System.in);
            int op = sc.nextInt();
            if (op == 1)
                machine.insertQuarter();
            else if (op == 2)
                machine.ejectQuarter();
            else if (op == 3)
                machine.trunCrank();
            else if (op == 4)
                machine.dispenseCandy();
            else
                System.out.println("输入有误，请重新输入...");
        }

    }
}

　  经过一番简单的测试，糖果机能正常工作，测试明细如下：

机器已经准备完毕，请您投入25分钱购买糖果~~~
当前糖果机还剩1颗糖果
请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果
1
【操作成功】成功投入25分钱，您的糖果已经在等您了哦~~
请您选择操作：退回25分钱 or 转动曲柄....
当前糖果机还剩1颗糖果
请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果
2
【操作成功】您的25分钱已经退回，欢迎下次光临~~~
机器已经准备完毕，请您投入25分钱购买糖果~~~
当前糖果机还剩1颗糖果
请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果
1
【操作成功】成功投入25分钱，您的糖果已经在等您了哦~~
请您选择操作：退回25分钱 or 转动曲柄....
当前糖果机还剩1颗糖果
请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果
1
无法投入25分钱，机器中已经有25分钱了
当前糖果机还剩1颗糖果
请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果
3
【操作成功】曲柄已经开始转动，您的糖果即将出炉,尽请稍候~~~
糖果已经为您准备好，请点击售出糖果按钮..
当前糖果机还剩1颗糖果
请您选择您要执行的操作：1-投入 25分钱  2-退回25分钱  3-转动曲柄  4-发放糖果
4
【操作成功】发放糖果1颗，尽情享受吧...
本糖果机所有糖果已经售罄，尽情下次光临哦~~~

　  看到代码中大量的if...else了吗，有没有觉得它们很不雅观？如果在此基础上，糖果机增加几个状态与动作，那么将会出现更大一大拨if...else，极大地降低了代码的可读性，提高了维护成本。

　  那么，如何使用State模式来重构此程序呢？

　  首先要定义一个State基类，包含上述四种动作。然后再分别定义四种不同状态的State子类，分别是：SoldState、SoldOutState、NoQuarterState和HasQuarterState，分别在对应的状态子类中实现不同的动作。

　  重构后的State以及其不同子类如下所示：

package state.candymachine;

public class State {

    // 转动曲柄
    public void trunCrank(CandyMachine machine) {
        System.out.println("无法转动曲柄，请先投入25分钱");
    }

    // 发放糖果
    public void dispenseCandy(CandyMachine machine) {
        System.out.println("无法发放糖果，请先转动曲柄");
    }

    // 投入25分钱
    public void insertQuarter(CandyMachine machine) {
        System.out.println("无法投入25分钱，机器中已经有25分钱了");
    }

    // 退回25分钱
    public void ejectQuarter(CandyMachine machine) {
        System.out.println("无法退回25分钱，您还未投入钱呢");
    }

}

/**
 * 售出糖果状态 
 * 本次售出后 糖果=0则转入“糖果售罄”状态 糖果>0则转入“无25分钱”状态
 */
class SoldState extends State {
    
    public SoldState() {
        System.out.println("糖果已经为您准备好，请点击售出糖果按钮..");
    }
    
    @Override
    public void dispenseCandy(CandyMachine machine) {
        System.out.println("【操作成功】发放糖果1颗，尽情享受吧...");
        int currCandyNums = machine.getCandyNums() - 1;
        machine.setCandyNums(currCandyNums);
        if (currCandyNums > 0) {
            machine.setState(new NoQuarterState());
        } else {
            machine.setState(new SoldOutState());
        }
    }
}

// 售罄状态
class SoldOutState extends State {
    public SoldOutState(){
        System.out.println("本糖果机所有糖果已经售罄，尽情下次光临哦~~~");
    }
}

// 无25分钱状态
class NoQuarterState extends State {
    
    public NoQuarterState() {
        System.out.println("机器已经准备完毕，请您投入25分钱购买糖果~~~");
    }
    
    @Override
    public void insertQuarter(CandyMachine machine) {
        System.out.println("【操作成功】成功投入25分钱，您的糖果已经在等您了哦~~");
        machine.setState(new HasQuarterState());
    }
}

// 有25分钱状态
class HasQuarterState extends State {
    
    public HasQuarterState() {
        System.out.println("请您选择操作：退回25分钱 or 转动曲柄....");
    }
    
    @Override
    public void trunCrank(CandyMachine machine) {
        System.out.println("【操作成功】曲柄已经开始转动，您的糖果即将出炉,尽请稍候~~~");
        machine.setState(new SoldState());
    }
    @Override
    public void ejectQuarter(CandyMachine machine) {
        System.out.println("【操作成功】您的25分钱已经退回，欢迎下次光临~~~");
        machine.setState(new NoQuarterState());
    }
}

　  然后，在糖果机类中使用State的一个实例对象来记录当前的状态，对于四种动作则分别交给当前State实例对象来处理。

　  重构后的糖果机类CandyMachine如下所示：

package state.candymachine;

public class CandyMachine {

    private State state;
    private int candyNums = 0;

    public CandyMachine(int candyNums) {
        this.candyNums = candyNums;
        if (candyNums > 0) {
            setState(new NoQuarterState());
        } else {
            setState(new SoldOutState());
        }
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public int getCandyNums() {
        return candyNums;
    }

    public void setCandyNums(int candyNums) {
        this.candyNums = candyNums;
    }
    
    public void trunCrank(){
        this.state.trunCrank(this);
    }
    
    public void dispenseCandy(){
        this.state.dispenseCandy(this);
    }
    
    public void insertQuarter(){
        this.state.insertQuarter(this);
    }
    
    public void ejectQuarter(){
        this.state.ejectQuarter(this);
    }

}

　  在重构后的代码中，不存在任何的条件分支语句，代码有了很好的可读性，也漂亮了许多，是么....