状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。当控制一个对象的状态转换条件分支语句（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);
}
}
在重构后的代码中，不存在任何的条件分支语句，代码有了很好的可读性，也漂亮了许多，是么....