Head First 设计模式 --10 状态模式

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

用到的设计原则
1、封装变化
2、多用组合，少用继承
3、针对接口编程，不针对实现编程
4、松耦合
5、对扩展开放，对修改关闭
6、依赖抽象，而不依赖具体
7、只和朋友交谈
8、别找我，我会找你
9、类应该只有一个修改的理由

例子来自《Head First设计模式》，糖果机的例子

interface State {

public void insertQuarter();

public void ejectQuarter();

public void turnCrank();

public void dispense();
}

class NoQuarterState implements State {
GumballMachine gumballMachine;

public NoQuarterState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}

public void insertQuarter() {
System.out.println("You inserted a quarter");
gumballMachine.setState(gumballMachine.hasQuarterState);
}

public void ejectQuarter() {
System.out.println("You haven't inserted a quarter");
}

public void turnCrank() {
System.out.println("You turned, but there's no quarter");
}

public void dispense() {
System.out.println("You need to pay first");
}

public String toString() {
return "waiting for quarter";
}
}

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("You can't insert another quarter");
}

public void ejectQuarter() {
System.out.println("Quarter returned");
gumballMachine.setState(gumballMachine.noQuarterState);
}

public void turnCrank() {
System.out.println("You turned...");

int winner = randomWinner.nextInt(10);
if ((winner == 0) && (gumballMachine.count > 1)) {
gumballMachine.setState(gumballMachine.winnerState);
} else {
gumballMachine.setState(gumballMachine.soldOutState);
}
}

public void dispense() {
System.out.println("No gumball dispensed");
}

public String toString() {
return "waiting for turn of crank";
}
}

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 insertQuarter() {
state.insertQuarter();
}

public void ejectQuarter() {
state.ejectQuarter();
}

public void turnCrank() {
state.turnCrank();
state.dispense();
}

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

void releaseBall() {
System.out.println("A gumball comes rolling out the slot...");
if (count != 0) {
count = count - 1;
}
}

}

public class StateTest {
public static void main(String[] args) {
GumballMachine gumballMachine = new GumballMachine(10);

gumballMachine.insertQuarter();
gumballMachine.turnCrank();
gumballMachine.insertQuarter();
gumballMachine.turnCrank();
}
}

类图：



上面的代码运行不了。缺少三种State，这里只是看一下要表达的意思。

装填模式将状态封装成独立的类，并将每个动作委托给当前状态的对象。如果对象能够完全改变它的行为，那么你会觉得，这个对象实际是从别的类实例化出来的，而实际上，我们是用组合通过简单引用不同的状态对象来造成类的改变的假象。

当我们看到上面的类图时，会发现这个类图和策略模式的类图是一样的。
策略模式：我们将一群行为封装在状态对象中，context的行为随时可委托到哪个状态对象中。随着状态的改变，以反应context的内部的状态。但是context的客户对于状态对象了解不多。状态模式代替多条件判断的设计方案，通过包装状态对象，在context内简单地改变状态对象。
装填模式：通常是主动指定context所要组合的对象是哪一个。这个对象一般情况不会改变，因为对于程序而言，他就是这个类型的，具有特定的行为。一般来说，策略模式是除了继承外一种弹性的设计方案。

状态模式：封装基于装填的行为，并将行为委托到当前状态
策略模式：将可以减缓的行为封装起来，然后使用委托的方法决定使用那一个行为
模板方法模式：由子类决定如何实现算法中的某个步骤