状态模式#

概述

例：通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态的改变，都有可能要根据其他状态来更新处理，例如电梯现在处于运行状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。

类图如下：

代码实现：

ILift 接口：电梯接口

package com.atguigu.state.before;
//电梯接口
public interface ILift {

    //定义四个电梯状态的常量
    int OPENING_STATE = 1;
    int CLOSING_STATE = 2;
    int RUNNING_STATE = 3;
    int STOPPING_STATE = 4;

    //设置电梯状态的功能
    void setState(int state);

    //电梯操作功能
    void open();

    void close();

    void run();

    void stop();
}

Lift 类：电梯类

package com.atguigu.state.before;

public class Lift implements ILift{

    //记录当前电梯的状态
    private int state;

    @Override
    public void setState(int state) {
        this.state = state;
    }

    @Override
    public void open() {
        switch(state){
            case OPENING_STATE:
                //do nothing

            case RUNNING_STATE:
                //do nothing
                System.out.println("do nothing");
                break;
            case CLOSING_STATE:
                System.out.println("电梯由 close --> open");
                setState(OPENING_STATE);
                break;
            case STOPPING_STATE:
                System.out.println("电梯由 stop --> open");
                setState(OPENING_STATE);
                break;
        }
    }

    @Override
    public void close() {
        switch(state){
            case OPENING_STATE:
                System.out.println("电梯由 open --> close");
                setState(CLOSING_STATE);
                break;
            case CLOSING_STATE:
                //do nothing

            case RUNNING_STATE:
                //do nothing

            case STOPPING_STATE:
                //do nothing
                System.out.println("do nothing");
                break;
        }
    }

    @Override
    public void run() {
        switch(state){
            case CLOSING_STATE:
                System.out.println("电梯由 closed --> run");
                setState(RUNNING_STATE);
                break;
            case STOPPING_STATE:
                System.out.println("电梯由 stop --> run");
                setState(RUNNING_STATE);
                break;
            case OPENING_STATE:
                //do nothing

            case RUNNING_STATE:
                //do nothing
                System.out.println("do nothing");
                break;
        }
    }

    @Override
    public void stop() {
        switch(state){
            case OPENING_STATE:
                //do nothing
            case STOPPING_STATE:
                //do nothing
                System.out.println("do nothing");
                break;
            case CLOSING_STATE:
                System.out.println("电梯由 close --> stop");
                setState(STOPPING_STATE);
                break;

            case RUNNING_STATE:
                System.out.println("电梯由 run --> stop");
                setState(STOPPING_STATE);
                break;
        }
    }
}

Client 类：测试类

package com.atguigu.state.before;

public class Client {
    public static void main(String[] args) {
        //创建电梯对象
        Lift lift = new Lift();

        //设置当前电梯的状态
        lift.setState(ILift.OPENING_STATE);

        lift.open();

        lift.close();

        lift.run();

        lift.stop();
    }
}

do nothing
电梯由 open --> close
电梯由 close --> run
电梯由 run --> stop

问题分析：

• 使用大量的switch-case判断结构，使得程序的可阅读性变差
• 扩展性很差，如果新增断电状态，需要修改原有的逻辑

状态模式定义：

对有状态的对象，把复杂的 “判断逻辑” 提取到不同的状态对象中，允许状态对象在其内部状态发生变化时改变其行为

结构

状态模式包含以下主要角色：

• 环境角色：又称上下文，定义客户程序需要的接口，维护一个当前状态，并将于状态相关的操作委托给当前状态对象来处理
• 抽象状态角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为
• 具体状态角色：实现抽象状态所对应的行为

案例

对上述电梯的案例使用状态模式进行改进，类图如下：

代码实现：

LiftState 抽象类：抽象状态类

package com.atguigu.state.after;
//抽象状态类
public abstract class LiftState {

    //定义环境角色,
    protected Context context;

    public void setContext(Context context){
        this.context = context;
    }

    public abstract void open();//开启

    public abstract void close();//关闭

    public abstract void stop();//停止

    public abstract void run();//运行

}

OpeningState 类：电梯开门

package com.atguigu.state.after;
//电梯开门
public class OpeningState extends LiftState {

    //当前状态要执行的操作

    @Override
    public void open() {
        System.out.println("电梯开启");
    }

    @Override
    public void close() {
        //修改状态
        super.context.setLiftState(Context.CLOSING_STATE);
        //调用当前状态中的context中的close()
        super.context.close();
    }

    @Override
    public void stop() {
        System.out.println("OpeningState has been stopping");
    }

    @Override
    public void run() {
        System.out.println("OpeningState don't run ");
    }
}

ClosingState 类：电梯关门

package com.atguigu.state.after;

//电梯关门
public class ClosingState extends LiftState {

    当前状态要执行的操作

    @Override
    public void open() {
        //修改状态
        super.context.setLiftState(Context.OPENING_STATE);
        //执行对于的方法
        super.context.open();
    }

    @Override
    public void close() {
        System.out.println("电梯关闭");
    }

    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }

    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }
}

RunningState 类：电梯运行

package com.atguigu.state.after;
//电梯运行
public class RunningState extends LiftState {

    //当前状态需要执行的操作
    @Override
    public void open() {
        System.out.println("RunningState don't open");
    }

    @Override
    public void close() {
        System.out.println("RunningState has been closed");
    }

    @Override
    public void stop() {
        //修改状态
        super.context.setLiftState(Context.STOPPING_STATE);
        //执行当前context中的stop()
        super.context.stop();
    }

    @Override
    public void run() {
        System.out.println("电梯运行");
    }
}

StoppingState 类：电梯停止

package com.atguigu.state.after;
//电梯停止
public class StoppingState extends LiftState {

    //当前状态需要执行的操作

    @Override
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }

    @Override
    public void close() {
        super.context.setLiftState(Context.CLOSING_STATE);
        super.context.close();
    }

    @Override
    public void stop() {
        System.out.println("电梯停止运行");
    }

    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }
}

Client 类：测试类

package com.atguigu.state.after;

public class Client {
    public static void main(String[] args) {
        //创建环境角色
        Context context = new Context();

        //设置当前电梯状态
        context.setLiftState(new RunningState());

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

RunningState don't open
RunningState has been closed
电梯运行
电梯停止运行

代码逻辑看懂了，但是状态之间的切换感觉很迷惑，不理解 ClosingState 和 StoppingState 之间还需要进行切换

优点：

• 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为
• 允许状态转换逻辑与状态对象合为一体，而不是成为一个条件语句块

缺点：

• 状态模式的使用必然会增加系统类和对象的个数
• 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱
• 状态模式对 “开闭原则” 的支持并不太好

使用场景

• 当一个对象的行为取决于让它的状态，并且它在必须运行时根据状态改变它的行为时，就可以考虑使用状态模式
• 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时

参考文献

链接：黑马程序员Java设计模式详解