Java设计模式 —— 【行为型模式】状态模式（State Pattern） 详解

一、模式介绍

应用程序中的有些对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。

状态模式是一种行为模式：他是将有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

【反例】一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。按照以往的开发惯例，就是大量的if...else...(switch…case)判断，不仅可读性会很差，拓展性也很差,如果新加了断电的状态，我们需要修改上面所有判断逻辑。

//开门状态
@Override
public void open() {
    switch (this.state) {
        case OPENING_STATE:
            ...
            break;
        case CLOSING_STATE:
            ...
            break;
        case RUNNING_STATE:
            ...
            break;
        case STOPPING_STATE:
            ...
            break;
    }
}
//关门状态
...
//运行状态
...
//停止状态
...

接下来我们用状态模式对其加以改进。

二、结构

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

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

三、优缺点

1、优点：

• 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为；
• 减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖；
• 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

2、缺点：

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

四、使用场景

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

五、案例演示

对上述电梯的案例使用状态模式进行改进。

类图如下：

抽象状态角色：

public abstract class State {
    private final RuntimeException EXCEPTION = new RuntimeException("状态不被允许...");
    //定义一个环境角色，也就是封装状态的变化引起的功能变化
    protected Context context;

    //设置电梯的状态
    public void setContext(Context context){
        this.context = context;
    }

    //电梯的动作
    public void open() {
        throw EXCEPTION;
    }
    public void close() {
        throw EXCEPTION;
    }
    public void run() {
        throw EXCEPTION;
    }
    public void stop() {
        throw EXCEPTION;
    }
}

具体状态角色【开门，关门，运行，停止】：

public class OpenState extends State {
    @Override
    public void open() {
        System.out.println("电梯门开启...");
    }

    @Override
    public void close() {
        //状态修改
        super.context.setState(Context.closeState);
        super.context.getState().close();
    }
}

public class CloseState extends State{
    @Override
    public void close() {
        System.out.println("电梯门关闭...");
    }

    @Override
    public void open() {
        super.context.setState(Context.openState);
        super.context.getState().open();
    }

    @Override
    public void run() {
        super.context.setState(Context.runState);
        super.context.getState().run();
    }

    @Override
    public void stop() {
        super.context.setState(Context.stopState);
        super.context.getState().stop();
    }
}

public class RunState extends State{
    @Override
    public void run() {
        System.out.println("电梯正在运行...");
    }

    @Override
    public void stop() {
        super.context.setState(Context.stopState);
        super.context.getState().stop();
    }
}

public class StopState extends State{
    @Override
    public void open() {
        //状态修改
        super.context.setState(Context.openState);
        super.context.getState().open();
    }

    @Override
    public void run() {
        //状态修改
        super.context.setState(Context.runState);
        super.context.getState().run();
    }

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

环境角色：

public class Context {
    //定义出所有的电梯状态
    public final static OpenState openState = new OpenState();//开门状态，这时候电梯只能关闭
    public final static CloseState closeState = new CloseState();//关闭状态，这时候电梯可以运行、停止和开门
    public final static RunState runState = new RunState();//运行状态，这时候电梯只能停止
    public final static StopState stopState = new StopState();//停止状态，这时候电梯可以开门、运行

    //定义一个当前电梯状态
    private State state;

    public State getState() {
        return this.state;
    }

    public void setState(State state) {
        //当前环境改变
        this.state = state;
        //把当前的环境通知到各个实现类中
        this.state.setContext(this);
    }

    public void open() {
        this.state.open();
    }

    public void close() {
        this.state.close();
    }

    public void run() {
        this.state.run();
    }

    public void stop() {
        this.state.stop();
    }
}

测试：

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setState(new CloseState());

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