《Head First 设计模式》第十章-状态模式 状态模式

状态模式

策略模式和状态模式是双胞胎，在出生时才分开。你已经知道，策略模式是围绕可以互换的算法来创建成功业务的，然而，状态走的是更崇高的路，它通过改变对象内部的状态来帮助对象控制自己的行为。

定义状态模式

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

例题

自动糖果售卖机，糖果机的控制器需要的工作流程如下图

从上面的状态图中可以找到所有的状态：

我们可以创建一个实例变量来持有目前的状态，然后定义每个状态的值：

1 2 3 4 5 6 7

//每个状态用不同的值表示 final static int SOLD_OUT=0;//售罄 final static int NO_QUARTER=1;//没有投币 final static int HAS_QUARTER=2;//已投币 final static int SOLD=3;//售出糖果 //实例变量持有当前状态，只要改变变量值状态也会随之改变 int state =SOLD_OUT;

现在,我们将所有系统中可以发生的动作整合起来：
“投入25分钱”，“退回25分钱”，“转动曲柄”，“发放糖果”
这些动作是糖果机的接口，这是你能对糖果机做的事情，
调用任何一个动作都会造成状态的转换，
发放糖果更多是糖果机的内部动作，机器自己调用自己。

我们创建一个类，它的作用就像是一个状态机，每一个动作，我们都创建了一个对应的方法，这些方法利用条件语句来决定在每个状态内什么行为是恰当的。比如对“投入25分钱”这个动作来说，我们可以把对应方法写成下面的样子：

1 2 3 4 5 6 7 8 9 10 11 12 13

public void insertQuarter(){     if(state==HAS_QUARTER){         //每个状态对应的行为          ......     }else if(state==SOLD_OUT){         ......     }else if(state ==SOLD){         ......     }else if(state==NO_QUARTER){         state=HAS_QUARTER;//状态转换         ......     } }

初步代码

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 75 76 77

class GumballMachine{     final static int SOLD_OUT=0;     final static int NO_QUARTER=1;     final static int HAS_QUARTER=2;     final static int SOLD=3;     int state =SOLD_OUT;     int count =0;//存储糖果数量     public  GumballMachine(int count){         this.count=count;         if(count>0){             state=NO_QUARTER;         }     }     //当有25分钱投入，就会执行这个方法     public void insertQuarter(){         if(state==HAS_QUARTER){             System.out.println("如果已投入过25分钱，我们就告诉顾客");         }else if(state==NO_QUARTER){             state=HAS_QUARTER;             System.out.println("如果是在“没有25分钱”的状态下，我们就接收25分钱，" +"并将状态转换到“有25分钱”的状态");         }else if(state ==SOLD_OUT){             System.out.println("如果糖果已经售罄，我们就拒绝收钱");         }else if(state==SOLD){             System.out.println("如果顾客刚才买了糖果，就需要稍等一下，好让状态转换完毕。" +"恢复到“没有25分钱”的状态");             state=NO_QUARTER;         }     }     //如果顾客试着退回25分钱就执行这个方法     public void ejectQuarter(){         if(state==HAS_QUARTER){             System.out.println("如果有25分钱，我们就把钱退出来，回到“没有25分钱”的状态");             state=NO_QUARTER;         }else if(state==NO_QUARTER){             System.out.println("如果没有25分钱的话，当然不能退出25分钱");         }else if(state ==SOLD){             System.out.println("顾客已经转动曲柄就不能再退钱了，他已经拿到糖果了");         }else if(state==SOLD_OUT){             System.out.println("如果糖果售罄，就不能接受25分钱，当然也不可能退钱");         }     }     //顾客试着转动曲柄     public void turnCrank(){         if(state==SOLD){             System.out.println("别想骗过机器拿两次糖果");         }else if(state==NO_QUARTER){             System.out.println("我们需要先投入25分钱");         }else if(state ==SOLD_OUT){             System.out.println("我们不能给糖果，已经没有任何糖果了");         }else if(state==HAS_QUARTER){             System.out.println("成功，他们拿到糖果了，" +"改变状态到“售出糖果”然后调用机器的disoense()方法");             state=SOLD;             dispense();         }     }     //调用此方法，发放糖果     public void dispense(){         if(state==SOLD){             System.out.println("我们正在“出售糖果”状态，给他们糖果");             count=count-1;             /*             我们在这里处理“糖果售罄”的情况，如果这是最后一个糖果，将机器的状态设置到“糖果售罄”否则就回到“没有25分钱”的状态              */             if(count==0){                 System.out.println();                 state=SOLD_OUT;             }else{                 state=NO_QUARTER;             }         }else if(state==SOLD_OUT){             System.out.println("这些都不应该发生，但是如果做了，就得到错误提示");         }else if(state ==HAS_QUARTER){             System.out.println("这些都不应该发生，但是如果做了，就得到错误提示");         }else if(state==NO_QUARTER){             System.out.println("这些都不应该发生，但是如果做了，就得到错误提示");         }     } }

尽管程序完美运行，但还是躲不掉需求变更的命运

现在糖果公司要求：当曲柄被转动时，有10%的几率掉下来的是两个糖果。（氪金扭蛋）

再回看一下我们的初步代码，想要实现新的需求将会变得非常麻烦：

• 必须新增一个中奖的“赢家”状态。
• 必须在每一个方法添加新的判断条件来处理“赢家”状态。
• 转动把手的方法中还需要检查目前状态是否是“赢家”再决定切换到“赢家”状态行为还是正常出售行为。

在现有代码基础上做增加将会很麻烦，也不利与以后的维护，扩展性差。

回顾一下第一章的策略模式中的设计原则：

找出应用中可能需要变化之处，把他们独立出来

将状态独立出来，封装成一个类，都实现State接口，类图如下：

新的设计想法如下：

1. 首先，我们定义一个State接口，在这个接口内，糖果机的每个动作都有一个对应的方法
2. 然后为机器的每个状态实现状态类，这些类将负责在对应的状态下进行机器的行为
3. 最后，我们要摆脱旧的条件代码，取而代之的方式是，将动作委托到状态类

代码

定义一个State接口

1 2 3 4 5 6

public interface State {     public void insertQuarter();//投币     public void ejectQuarter();//退币     public void turnCrank();//转动出货把手     public void dispense();//出售 }

为机器的每个状态实现状态类：

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 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

//未投币状态 public class NoQuarterState implements State {     GumballMachine gumballMachine;     public NoQuarterState(GumballMachine gumballMachine) {         this.gumballMachine=gumballMachine;     }     public void insertQuarter() {         System.out.println("你投入一枚硬币");         gumballMachine.setState(gumballMachine.getHasQuarterState());//状态转换为已投币状态     }     public void ejectQuarter() {         System.out.println("你未投币，无法退钱");     }     public void turnCrank() {         System.out.println("未投币，请先投币");     }     public void dispense() {         System.out.println("请先投币");     } }   //已投币状态 public class HasQuarterState implements State {     Random randomWinner=new Random(System.currentTimeMillis());     GumballMachine gumballMachine;     public HasQuarterState(GumballMachine gumballMachine) {         this.gumballMachine=gumballMachine;     }     public void insertQuarter() {         System.out.println("已投币，无法再接收投币");     }     public void ejectQuarter() {         System.out.println("已退币");         gumballMachine.setState(gumballMachine.getNoQuarterState());     }     public void turnCrank() {         System.out.println("已转动把手，糖果出售中。。。。");         int winner=randomWinner.nextInt(10);//随机数生成，用以标记“赢家”状态         if((winner==0)&&(gumballMachine.getCount()>1))             gumballMachine.setState(gumballMachine.getWinnerState());         else             gumballMachine.setState(gumballMachine.getSoldState());     }     public void dispense() {         System.out.println("机器中已经没有糖果可以出售了！");     } }   //出售状态 public class SoldState implements State {     GumballMachine gumballMachine;     public SoldState(GumballMachine gumballMachine) {         this.gumballMachine=gumballMachine;     }     public void insertQuarter() {         System.out.println("请等候，正在初始化机器中");     }     public void ejectQuarter() {         System.out.println("抱歉，您已转动把手获得了糖果,无法退币");     }     public void turnCrank() {         System.out.println("您重复转动把手，无法再获取更多糖果");     }     public void dispense() {         gumballMachine.releaseBall();//出货，糖果-1         if(gumballMachine.getCount()>0)             gumballMachine.setState(gumballMachine.getNoQuarterState());         else {             System.out.println("糖果已售完");             gumballMachine.setState(gumballMachine.getSoldOutState());         }        } }   //售罄状态 public class SoldOutState implements State {     GumballMachine gumballMachine;     public SoldOutState(GumballMachine gumballMachine) {         this.gumballMachine=gumballMachine;     }     public void insertQuarter() {         System.out.println("此机器的糖果已售完，不接收投币");     }     public void ejectQuarter() {         System.out.println("未投币，退币失败");     }     public void turnCrank() {         System.out.println("糖果已售完，转动把手也不会有糖果出来的");     }     public void dispense() {         System.out.println("机器中已无糖果");     } }   //赢家状态 public class WinnerState implements State {     GumballMachine gumballMachine;     public WinnerState(GumballMachine gumballMachine) {         this.gumballMachine=gumballMachine;     }     public void insertQuarter() {         System.out.println("请等候，正在初始化机器中");     }     public void ejectQuarter() {         System.out.println("抱歉，您已转动把手获得了糖果");     }     public void turnCrank() {         System.out.println("您重复转动把手，无法再获取更多糖果");     }     public void dispense() {         System.out.println("恭喜你成为幸运儿，你将额外获得一个免费糖果");         gumballMachine.releaseBall();//出货，糖果-1         if(gumballMachine.getCount()==0)             gumballMachine.setState(gumballMachine.getSoldOutState());         else {             gumballMachine.releaseBall();             if(gumballMachine.getCount()>0)                 gumballMachine.setState(gumballMachine.getNoQuarterState());             else {                 System.out.println("糖果已售完");                 gumballMachine.setState(gumballMachine.getSoldOutState());             }         }     } }

糖果机类：

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

public class GumballMachine {     State soldOutState;     State noQuarterState;     State hasQuarterState;     State soldState;     State winnerState;       State state=soldOutState;     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;//先判断条件再改变状态     }     //将动作委托到状态类     public void insterQuarter() {         state.insertQuarter();     }     public void ejectQuarter() {         state.ejectQuarter();     }     public void turnCrank() {         state.turnCrank();         state.dispense();     }     //获取当前状态     public State getHasQuarterState() {         return hasQuarterState;     }     //改变状态     public void setState(State state) {         this.state=state;     }     public void releaseBall() {         System.out.println("糖果从出口售出");         if(count!=0)             count-=1;     }     public State getSoldOutState() {         return soldOutState;     }     public State getNoQuarterState() {         return noQuarterState;     }     public State getSoldState() {         return soldState;     }     //获取糖果机中糖果数量     public int getCount() {         return count;     }       public State getWinnerState() {         return winnerState;     }     public String toString() {         // TODO 自动生成的方法存根         String s="剩余糖果："+count;         return s;     } }

以上就是用状态模式实现的，仔细观察你会发现状态模式其实和策略模式很像，来看看状态模式的类图：

状态模式的类图其实和策略模式完全一样！

状态模式与策略模式

这两个模式的差别在于它们的“意图”

• 以状态模式而言，我们将一群行为封装在状态对象中，context的行为随时可委托到那些状态对象中的一个，随着时间而流逝，当前状态在状态对象集合中游走改变，以反映出context内部的状态，因此，context的行为也会跟着改变，但是context的客户对于状态对象了解不多，甚至根本是浑然不觉。
• 以策略模式而言，客户通常主动指定Context所要组合的策略对象时哪一个。现在，固然策略模式让我们具有弹性，能够在运行时改变策略，但对于某个context对象来说，通常都只有一个最适当的策略对象。
• 一般的，我们把策略模式想成是除了继承之外的一种弹性替代方案，如果你使用继承定义了一个类的行为，你将被这个行为困住，是指要修改它都很难，有了策略模式，你可以通过组合不同的对象来改变行为。
• 我们把状态模式想成是不用在context中放置许多条件判断的替代方案，通过将行为包装进状态对象中，你可以通过在context内简单地改变状态对象来改变context的行为。

模式区分

状态模式：封装基于状态的行为，并将行为委托到当前状态

策略模式：将可以互换的行为封装起来。然后使用委托的方法，觉得使用哪一个行为

模板方法模式：由子类决定如何实现算法中的某些步骤

要点

（1）状态模式允许一个对象基于内部状态而拥有不同的行为。

（2）和程序状态机（PSM）不同，状态模式用类来表示状态。

（3）Context会将行为委托给当前状态对象。

（4）通过将每一个状态封装进一个类，我们把以后需要做的任何改变局部化了。

（5）状态模式和策略模式有相同的类图，但是他们的意图不同。

（6）策略模式通常会用行为或算法配置Context类。

（7）状态模式允许Context随着状态的改变而改变行为。

（8）状态转换可以有State类或Context类控制。

（9）使用状态模式通常会导致设计中类的数目大量增加。

（10）状态栏可以被多个Context实例共享。