一、是什么

1. 定义: 封装了基于状态的行为，并使用委托在行为之间切换

2. 好处: 通过将每个状态封装到类中，将以后需要做的任何改变局部化

3. 缺点: 使用状态类通常会导致设计类的数量大量增加

4. 类图如上，和策略模式的类图相同，目的不同，策略是为了封装互换的行为，用委托来解耦，状态模式的目的是将状态封装成类，用委托来切换状态

二、示例

场景：假设冲一杯咖啡的步骤是，1. 拿一个空杯子 2. 往杯子中添加速溶咖啡 3. 往杯子中加水

该场景中有三个状态： 1. 空杯子 2. 装有速溶咖啡的杯子 2. 装水的杯子

原来的实现：

　　写了个大概的假代码, 这里只有拿杯子的方法，里面就有了四个if判断, 后面的方法还是继续if判断，相对麻烦一点, 当然最重要的是如果以后要变化步骤的话，整个类都在影响范围之类。而状态模式在这里可以帮我们将变化局部化

final static int NO_CUP = 0                    // 还没有杯子的状态
final static int EMPTY_CUP = 1                 // 空杯
final static int INSTANT_COFFEE_CUP = 2        // 装有速溶咖啡粉的杯子
final static int ENJOY_CUP = 3                 // 冲好咖啡, 美滋滋的杯子

// 拿杯子的方法
public void takeCup() {
    if (state == NO_CUP) {
        // 此时没有杯子, 所以我就拿了一个空杯子
        state = EMPTY_CUP;
    } else if (state == EMPTY_CUP) {
        // 已经有一个空杯子了, 不需要再拿了
    } else if (state == INSTANT_COFFEE_CUP) {
        // 已经有一个装有速溶咖啡粉的杯子, 不需要再拿了
    } else if (state == ENJOY_CUP) {
        // 已经冲好咖啡了, 不需要再拿了
    }
}

现有的实现:

1. 状态类

1. 1 状态类的接口

/**
 * 状态接口
 */
public interface State {

    /**
     * 1. 拿杯子
     */
    void takeCup();

    /**
     * 2. 往杯子中添加速溶咖啡
     */
    void addInstantCoffe();

    /**
     * 3. 往杯子中加水
     */
    void addWater();

    /**
     * 4. 尽情的享受咖啡
     */
    void enjoyCoffe();
}

1.2 没有杯子的状态类

/**
 * 0. 没有杯子的状态
 */
public class NoCupState implements State {
    private MakeCoffe makeCoffe;

    public NoCupState(MakeCoffe makeCoffe) {
        this.makeCoffe = makeCoffe;
    }

    @Override
    public void takeCup() {
        makeCoffe.state = makeCoffe.emptyCupState;
        System.out.println("拿了一个杯子");
    }

    @Override
    public void addInstantCoffe() {
        System.out.println("还没有一个杯子, 需要拿个杯子");
    }

    @Override
    public void addWater() {
        System.out.println("还没有一个杯子, 需要拿个杯子");
    }

    @Override
    public void enjoyCoffe() {
        System.out.println("现在还没有杯子, 享受不了啊");
    }
}

1.3 空杯子的状态

/**
 * 1. 有个空杯子的状态
 */
public class EmptyCupState implements State {
    private MakeCoffe makeCoffe;

    public EmptyCupState(MakeCoffe makeCoffe) {
        this.makeCoffe = makeCoffe;
    }

    @Override
    public void takeCup() {
        System.out.println("已经有个空杯子了, 不需要再");
    }

    @Override
    public void addInstantCoffe() {
        this.makeCoffe.state = makeCoffe.instantCoffeCupState;
        System.out.println("往杯子加了速溶咖啡");
    }

    @Override
    public void addWater() {
        System.out.println("杯子中还需要先加速溶咖啡粉, 再加水");
    }

    @Override
    public void enjoyCoffe() {
        System.out.println("现在还是空杯子, 享受不了啊");
    }
}

1.4 加了速溶咖啡的状态

/**
 * 2. 加了速溶咖啡的状态
 */
public class InstantCoffeCupState implements State {
    private MakeCoffe makeCoffe;

    public InstantCoffeCupState(MakeCoffe makeCoffe) {
        this.makeCoffe = makeCoffe;
    }

    @Override
    public void takeCup() {
        System.out.println("杯子中已经加了速溶咖啡了, 不需要在拿一个了");
    }

    @Override
    public void addInstantCoffe() {
        System.out.println("杯子中已经加了速溶咖啡了, 不需要再放速溶咖啡了");
    }

    @Override
    public void addWater() {
        makeCoffe.state = makeCoffe.coffeOkState;
        System.out.println("往有速溶咖啡的杯子里, 加水");
    }

    @Override
    public void enjoyCoffe() {
        System.out.println("现在杯子中还没加水, 享受不了啊");
    }
}

1.5 加完水，咖啡冲好的状态，享受咖啡

/**
 * 4. 咖啡冲好, 享受咖啡
 */
public class CoffeOkState implements State {
    @Override
    public void takeCup() {
        System.out.println("咖啡已经冲好了, 不需要再拿一个杯子了");
    }

    @Override
    public void addInstantCoffe() {
        System.out.println("咖啡已经冲好了, 不需要再加速溶咖啡了");
    }

    @Override
    public void addWater() {
        System.out.println("咖啡已经冲好了, 不需要再加水了");
    }

    @Override
    public void enjoyCoffe() {
        System.out.println("享受咖啡咯");
    }
}

2. 制作咖啡的类

/**
 * 制作咖啡的类
 */
public class MakeCoffe {

    /**
     * 这杯咖啡的状态
     */
    public State state;

    /**
     * 没有杯子状态
     */
    public NoCupState noCupState;
    /**
     * 有一个空杯子状态
     */
    public EmptyCupState emptyCupState;
    /**
     * 杯子里有速溶咖啡粉状态
     */
    public InstantCoffeCupState instantCoffeCupState;
    /**
     * 冲好咖啡状态
     */
    public CoffeOkState coffeOkState;

    public MakeCoffe() {
        this.noCupState = new NoCupState(this);
        this.emptyCupState = new EmptyCupState(this);
        this.instantCoffeCupState = new InstantCoffeCupState(this);
        this.coffeOkState = new CoffeOkState();

        // 设置默认状态
        this.state = this.noCupState;
    }

    // 拿杯子
    public void takeCup() {
        state.takeCup();
    }

    // 加入速溶咖啡
    public void addInstantCoffe() {
        state.addInstantCoffe();
    }

    // 加水
    public void addWater() {
        state.addWater();
    }

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

3. 测试

/**
 * 享受咖啡测试类
 */
public class EnjoyCoffeMain {

    public static void main(String[] args) {
        MakeCoffe makeCoffe = new MakeCoffe();

        makeCoffe.takeCup();
        makeCoffe.addInstantCoffe();
        makeCoffe.addWater();
        makeCoffe.enjoyCoffe();
    }
}

// 控制台显示
拿了一个杯子
往杯子加了速溶咖啡
往有速溶咖啡的杯子里, 加水
享受咖啡咯

1. 恭喜这个程序猿在没有写很多IF判断的情况下，成功享受到咖啡, 状态模式这里我觉得好处就是可以将变化分开封装，以后 要是某个状态中的操作改了，不需要查找整个IF了，找到对应类修改。

2. 或者以后添加某个状态的话，如卡布奇诺需要加奶加糖等，就不需要修改IF, 而是添加状态，修改部分状态中的代码

3. 带来的缺点就是，增加了很多的类

三、总结

想想自己两年前理解的状态的模式，现在比以前更理解一点了

版权声明：本文为milicool原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/milicool/p/11278671.html