示例

一个类对外提供了多个行为，同时该类对象有多种状态，不同状态下对外的

行为的表现不同，我们该如何来设计该类让它对状态可以灵活扩展？

以自动售卖饮料机为例开发一个程序：

用户可以在饮料机上进行支付、退款、购买、取货操作
不同的状态下，这四种操作会有不同的表现

例如：在用户没有支付的情况下，用户操作了退款、购买、取货会发生什么

简单例子

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 个

状态模式-命令模式-策略模式

策略模式：侧重的是一个行为的多个算法实现，可互换算法，比如优惠活动满减和打折都是算法，可以选择其中一个来买买买

命令模式：侧重的是为多个行为提供灵活的执行方式，比如上面的奶茶，每个顾客购买奶茶的命令都是一个行为，而不同的奶茶制作方式不一样，则就需要灵活的去制作奶茶

状态模式：应用于状态机的情况

设计原则：

区分变与不变，隔离变化
面向接口编程
多用组合，少用继承

巴特西

曾侯乙编钟引发的遐想之Java设计模式：状态模式

示例