行为型模式-状态模式

（1）概述

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

（2）结构

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

（3）案例

以乘坐电梯为例

环境角色

public class Context {

    /**
     * 对应状态对象的常量
     */
    public final static OpeningState OPENING_STATE = new OpeningState();
    public final static ClosingState CLOSING_STATE = new ClosingState();
    public final static RunningState RUNNING_STATE = new RunningState();
    public final static StoppingState STOPPING_STATE = new StoppingState();

    /**
     * 当前电梯状态变量
     */
    private LiftState liftState;

    public LiftState getLiftState() {
        return liftState;
    }

    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        //设置当前状态对象中的Context对象
        liftState.setContext(this);
    }

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

具体状态角色

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

    }

    @Override
    public void stop() {

    }
}

public class RunningState 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.STOPPING_STATE);
        super.context.stop();
    }
}

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 run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }

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

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 run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }

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

Client

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

（4）优缺点

• 将所有与某个状态相关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为
• 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块
• 可能导致类和对象的个数增多
• 结果与实现较为复杂，若果使用不当可能会导致结构与代码的混乱
• 不符合开闭原则

（5）使用场景

• 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变他的行为时
• 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时