问题引入

• 设计一个电梯，其拥有开门、关门、停止、运行四种状态。每一种状态的改变都需要根据其他状态来更新处理。

// ILift.java
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.java
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:
                // 什么事都不做
                break;
            case CLOSING_STATE:
            case STOPPING_STATE:
                System.out.println("电梯打开了.");
                // 设置当前状态为开启状态
                setState(OPENING_STATE);
                break;
            // 设置当前状态为开启状态
            case RUNNING_STATE:
                // 什么事都不做
                break;
        }
    }

    @Override
    public void close() {
        switch (state){
            case OPENING_STATE:
                System.out.println("电梯关闭了.");
                this.setState(CLOSING_STATE);
                break;
            case CLOSING_STATE:
            case STOPPING_STATE:
            case RUNNING_STATE:
                break;
        }
    }

    @Override
    public void run() {
        switch (state){
            case OPENING_STATE:
            case STOPPING_STATE:
                break;
            case CLOSING_STATE:
            case RUNNING_STATE:
                System.out.println("电梯运行了.");
                this.setState(RUNNING_STATE);
                break;
        }
    }

    @Override
    public void stop() {
        switch (state){
            case OPENING_STATE:
            case STOPPING_STATE:
                break;
            case CLOSING_STATE:
            case RUNNING_STATE:
                System.out.println("电梯停止了.");
                this.setState(STOPPING_STATE);
                break;
        }
    }
}

// Client.java
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();
    }
}

• 分析：这种实现方法使用了大量的swict...case语句，使得程序的可读性变差；
• 扩展性很差，如果加入了新的状态，则需要修改之前的判断逻辑。

状态模式

• 对有状态的对象，把复杂的"判断逻辑"提取到不同的状态对象中，允许状态对象在其内部状态方式改变时改变其行为。

结构

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

实例

// 抽象状态类
// LiftState.java
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();
}


// 环境角色类
// Context.java
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对象
        this.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();
    }
}

// 具体状态类
// OpeningState.java
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();

        System.out.println();
    }

    @Override
    public void run() {
        // 什么都不做
    }

    @Override
    public void stop() {
        // 什么都不做
    }
}

// 具体状态类
// ClosingState.java
public class ClosingState extends LiftState{
    @Override
    public void close() {
        System.out.println("电梯门关闭.");
    }

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



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

// 具体状态类
//  RunningState.java
public class RunningState extends LiftState{

    @Override
    public void open() {
        //do nothing
    }


    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        //do nothing
    }


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


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

// 具体状态类
// StoppingState.java
public class StoppingState extends LiftState{
    @Override
    public void open() {

        super.context.setLiftState(Context.OPENING_STATE);

        super.context.getLiftState().open();
    }

    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行

        super.context.setLiftState(Context.CLOSING_STATE);

        super.context.getLiftState().close();
    }


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

        super.context.getLiftState().run();
    }

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

// Client.java
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();
    }
}

• 这样的实现方法最明显的特点就是将业务的处理逻辑与状态对象合为一体，而不是利用一个巨大的判断语句。