曾侯乙编钟引发的遐想之Java设计模式：状态模式
示例
一个类对外提供了多个行为，同时该类对象有多种状态，不同状态下对外的
行为的表现不同，我们该如何来设计该类让它对状态可以灵活扩展？
以自动售卖饮料机为例开发一个程序：
- 用户可以在饮料机上进行支付、退款、购买、取货操作
- 不同的状态下，这四种操作会有不同的表现
例如：在用户没有支付的情况下，用户操作了退款、购买、取货会发生什么
简单例子
public class DrinksSellingMachine {
//未支付
final static int NO_PAY = 0;
//已支付
final static int PAY = 1;
//待取货
final static int SOLD = 2;
//已售罄
final static int SOLD_OUT = 4;
//当前状态
private int state = SOLD_OUT;
//当前库存
private int store;
public DrinksSellingMachine(int store) {
this.store = store;
if(this.store > 0) {
this.state = NO_PAY;
}
}
/** 支付 */
public void pay() {
switch (this.state) {
case NO_PAY :
System.out.println("支付成功，请确定购买饮料。");
this.state = PAY;
break;
case PAY :
System.out.println("已支付成功，请确定购买饮料。");
break;
case SOLD :
System.out.println("待取饮料中，请稍后购买。");
break;
case SOLD_OUT :
System.out.println("饮料已售罄，不可购买。");
break;
}
}
/** 退款 */
public void refund() {
switch (this.state) {
case NO_PAY :
System.out.println("尚未支付，请不要乱按。");
break;
case PAY :
System.out.println("退款成功。");
this.state = NO_PAY;
break;
case SOLD :
System.out.println("已购买，请取用。");
break;
case SOLD_OUT :
System.out.println("饮料已售罄，不可购买。");
break;
}
}
/** 购买 */
public void buy() {
switch (this.state) {
case NO_PAY :
System.out.println("尚未支付，请不要乱按。");
break;
case PAY :
System.out.println("购买成功，请取用。");
this.state = SOLD;
break;
case SOLD :
System.out.println("已购买，请取用。");
break;
case SOLD_OUT :
System.out.println("饮料已售罄，不可购买。");
break;
}
}
/** 取货 */
public void getGoods() {
switch (this.state) {
case NO_PAY :
System.out.println("尚未支付，请不要乱按。");
break;
case PAY :
System.out.println("已购买，请取用。");
case SOLD :
System.out.println("正在出货中，请等待三秒。");
this.store--;
if (this.store == 0) {
this.state = SOLD_OUT;
} else {
this.state = NO_PAY;
}
break;
case SOLD_OUT :
System.out.println("饮料已售罄，不可购买。");
break;
}
}
}
看到上面一大段代码，感觉很懵，如果现在需要扩展状态怎么办，需要对每一种操作下的方法进行修改，这将是一件麻烦的事情
如何能够灵活的扩展状态呢
四种操作是不会变的，但是状态是可以灵活变化的，下面改进代码：
改进代码
定义一个接口，每一种状态需要实现该接口：
public interface State {
/** 支付 */
void pay();
/** 退款 */
void refund();
/** 购买 */
void buy();
/** 取货 */
void getGoods();
}
未支付状态实现类：
public class NoPayState implements State {
private NewDrinksSellingMatchine matchine;
public NoPayState(NewDrinksSellingMatchine matchine) {
this.matchine = matchine;
}
@Override
public void pay() {
System.out.println("支付成功，请确定购买饮料。");
this.matchine.state = this.matchine.PAY;
}
@Override
public void refund() {
System.out.println("尚未支付，请不要乱按。");
}
@Override
public void buy() {
System.out.println("尚未支付，请不要乱按。");
}
@Override
public void getGoods() {
System.out.println("尚未支付，请不要乱按。");
}
}
支付状态实现类：
public class PayState implements State{
private NewDrinksSellingMatchine matchine;
public PayState(NewDrinksSellingMatchine matchine) {
this.matchine = matchine;
}
@Override
public void pay() {
System.out.println("已支付成功，请确定购买饮料。");
}
@Override
public void refund() {
System.out.println("退款成功。");
this.matchine.state = this.matchine.NO_PAY;
}
@Override
public void buy() {
System.out.println("已购买，请取用。");
this.matchine.state = this.matchine.SOLD;
}
@Override
public void getGoods() {
System.out.println("请先确定购买。");
}
}
其他两种状态就不在这展示了，和上面两种差不多
public class NewDrinksSellingMatchine {
final State NO_PAY, PAY, SOLD, SOLD_OUT;
State state;
int store;
public NewDrinksSellingMatchine(int store) {
NO_PAY = new NoPayState(this);
PAY = new PayState(this);
SOLD = new SoldState(this);
SOLD_OUT = new SoldOutState(this);
this.store = store;
if(this.store > 0) {
this.state = NO_PAY;
}
}
public void pay() {
this.state.pay();
}
public void refund() {
this.state.refund();
}
public void buy() {
this.state.buy();
}
public void getGoods() {
this.state.getGoods();
}
}
改进之后，如果需要对状态进行扩展，只需要实现State的接口就行了
状态模式
定义
一个类对外提供了多个行为，同时该类对象有多种状态，不同状态下对外的
行为的表现不同
意图
允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类
主要解决问题
对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为
何时使用
代码中包含大量与对象状态有关的条件语句
优缺点
优点：
- 封装了转换规则
- 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为
- 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块
- 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数
缺点：
- 状态模式的使用必然会增加系统类和对象的个数
- 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱
- 状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码
类图：
涉及的角色：
- 抽象状态（State）角色：定义一个接口，用来封装环境（Context）对象的一个特定的状态所对应的行为
- 具体状态（ConcreteState）角色：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为
- 环境（Context）角色：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例，这个具体状态类的实例给出此环境对象的现有状态
对应的代码如下：
State接口：
public interface State {
void sampleOperation();
}
ConcreteState类：
public class ConcreteState implements State {
@Override
public void sampleOperation() {
}
}
Context类：
public class Context {
private State state;
public void sampleOperation() {
this.state.sampleOperation();
}
public void setState(State state) {
this.state = state;
}
}
曾侯乙编钟
曾侯乙编钟，1979年在湖北出土，一套共65件，总音域跨5个八度，12个半音齐全，每一只钟都发出不同的音
下面以曾侯乙编钟为例，熟悉一下状态模式：
每一只钟都需要实现的接口：
public interface ClockState {
/** 打击钟 */
void blow();
void otherClock();
}
具体每一只钟的实现：
public class ClockConcreteStateC implements ClockState {
@Override
public void blow() {
System.out.println("钟C被打击");
}
@Override
public void otherClock() {
System.out.println("钟A B没有被打击");
}
}
public class ClockConcreteStateB implements ClockState {
@Override
public void blow() {
System.out.println("钟B被打击");
}
@Override
public void otherClock() {
System.out.println("钟A C没有被打击");
}
}
public class ClockConcreteStateA implements ClockState {
@Override
public void blow() {
System.out.println("钟A被打击");
}
@Override
public void otherClock() {
System.out.println("钟B C没有被打击");
}
}
曾候乙编钟，乐师选择一个钟打击它，每一只钟的每个音代表一个状态：
public class ClockContext {
private ClockState state;
public void blow() {
this.state.blow();
this.state.otherClock();
}
public void setState(ClockState state) {
this.state = state;
}
}
测试类：
public class Test {
public static void main(String[] args) {
ClockContext context = new ClockContext();
context.setState(new ClockConcreteStateA());
context.blow();
}
}
类图：
注意事项：在行为受状态约束的时候使用状态模式，而且状态不超过 5 个
状态模式-命令模式-策略模式
策略模式：侧重的是一个行为的多个算法实现，可互换算法，比如优惠活动满减和打折都是算法，可以选择其中一个来买买买
命令模式：侧重的是为多个行为提供灵活的执行方式，比如上面的奶茶，每个顾客购买奶茶的命令都是一个行为，而不同的奶茶制作方式不一样，则就需要灵活的去制作奶茶
状态模式：应用于状态机的情况
设计原则：
- 区分变与不变，隔离变化
- 面向接口编程
- 多用组合，少用继承
