设计模式——行为型——状态模式

一、理论

Allow an object to alter its behavior when its internal state changes.The object will appear to change its class.
当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。

状态模式的核心是封装，状态的变更引起了行为的变更，从外部看起来就好像这个对象对应的类发生了改变一样。

• State——抽象状态角色
  接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。
• ConcreteState——具体状态角色
  每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。
• Context——环境角色
  定义客户端需要的接口，并且负责具体状态的切换。

二、代码

模拟一个电梯的状态：开门、关门、运行、停止
当开门的时候，肯定不允许运行，运行时，肯定不会开门，等等
State——抽象状态角色

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 run();

    public abstract void stop();
}

ConcreteState——具体状态角色

public class OpenLiftState extends LiftState {


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

    //开启时可以关闭
    @Override
    public void close() {
        super.context.setLiftState(Context.closeLiftState);
        super.context.getLiftState().close();
    }

    @Override
    public void run() {

    }

    @Override
    public void stop() {

    }
}

public class CloseLiftState extends LiftState {

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

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

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

    @Override
    public void stop() {

    }
}

public class RunLiftState extends LiftState {

    @Override
    public void open() {

    }

    @Override
    public void close() {

    }

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

    //运行时只能停止
    @Override
    public void stop() {
        super.context.setLiftState(Context.stopLiftState);
        super.context.getLiftState().stop();
    }
}

public class StopLiftState extends LiftState {

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

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

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

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

Context——环境角色

public class Context {
    public static OpenLiftState openLiftState = new OpenLiftState();
    public static CloseLiftState closeLiftState = new CloseLiftState();
    public static RunLiftState runLiftState = new RunLiftState();
    public static StopLiftState stopLiftState = new StopLiftState();

    private LiftState liftState;

    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        this.liftState.setContext(this);
    }

    public LiftState getLiftState() {
        return this.liftState;
    }

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

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

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

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

测试：

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setLiftState(new CloseLiftState());
        context.open();
        context.close();
        context.run();
        context.stop();
        context.open();
        context.close();
    }
}

三、总结

1. 代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中
2. 方便维护。将容易产生问题的 if-else 语句删除了，如果把每个状态的行为都放到一个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多 if-else 语句，而且容易出错
3. 符合“开闭原则”。容易增删状态
4. 会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度
5. 应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候， 可以考虑使用状态模式