1.概述

定义：

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

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

类图如下：

在这里插入图片描述

public interface ILift {//电梯的4个状态//开门状态public final static int OPENING_STATE = 1;//关门状态public final static int CLOSING_STATE = 2;//运行状态public final static int RUNNING_STATE = 3;//停止状态public final static int STOPPING_STATE = 4;
//设置电梯的状态public void setState(int state);
//电梯的动作public void open();public void close();public void run();public void stop();
}

public class Lift implements ILift {private int state;
@Overridepublic void setState(int state) {this.state = state;}
//执行关门动作@Overridepublic void close() {switch (this.state) {case OPENING_STATE:System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了break;case CLOSING_STATE://do nothing //已经是关门状态，不能关门break;case RUNNING_STATE://do nothing //运行时电梯门是关着的，不能关门break;case STOPPING_STATE://do nothing //停止时电梯也是关着的，不能关门break;}}
//执行开门动作@Overridepublic void open() {switch (this.state) {case OPENING_STATE://门已经开了，不能再开门了//do nothingbreak;case CLOSING_STATE://关门状态，门打开:System.out.println("电梯门打开了。。。");this.setState(OPENING_STATE);break;case RUNNING_STATE://do nothing 运行时电梯不能开门break;case STOPPING_STATE:System.out.println("电梯门开了。。。");//电梯停了，可以开门了this.setState(OPENING_STATE);break;}}
//执行运行动作@Overridepublic void run() {switch (this.state) {case OPENING_STATE://电梯不能开着门就走//do nothingbreak;case CLOSING_STATE://门关了，可以运行了System.out.println("电梯开始运行了。。。");this.setState(RUNNING_STATE);//现在是运行状态break;case RUNNING_STATE://do nothing 已经是运行状态了break;case STOPPING_STATE:System.out.println("电梯开始运行了。。。");this.setState(RUNNING_STATE);break;}}
//执行停止动作@Overridepublic void stop() {switch (this.state) {case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)//do nothingbreak;case CLOSING_STATE://关门时才可以停止System.out.println("电梯停止了。。。");this.setState(STOPPING_STATE);break;case RUNNING_STATE://运行时当然可以停止了System.out.println("电梯停止了。。。");this.setState(STOPPING_STATE);break;case STOPPING_STATE://do nothingbreak;}}
}

public class Client {public static void main(String[] args) {Lift lift = new Lift();lift.setState(ILift.STOPPING_STATE);//电梯是停止的lift.open();//开门lift.close();//关门lift.run();//运行lift.stop();//停止}
}

问题分析：

使用了大量的switch…case这样的判断（if…else也是一样)，使程序的可阅读性变差。
扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

2 结构

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

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

3 案例实现

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

在这里插入图片描述
代码如下：

//抽象状态类
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 OpenningState extends LiftState {
//开启当然可以关闭了，我就想测试一下电梯门开关功能@Overridepublic void open() {System.out.println("电梯门开启...");}
@Overridepublic void close() {//状态修改super.context.setLiftState(Context.closeingState);//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作super.context.getLiftState().close();}
//电梯门不能开着就跑，这里什么也不做@Overridepublic void run() {//do nothing}
//开门状态已经是停止的了@Overridepublic void stop() {//do nothing}
}

//运行状态
public class RunningState extends LiftState {
//运行的时候开电梯门？你疯了！电梯不会给你开的@Overridepublic void open() {//do nothing}
//电梯门关闭？这是肯定了@Overridepublic void close() {//虽然可以关门，但这个动作不归我执行//do nothing}
//这是在运行状态下要实现的方法@Overridepublic void run() {System.out.println("电梯正在运行...");}
//这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了@Overridepublic void stop() {super.context.setLiftState(Context.stoppingState);super.context.stop();}
}

//停止状态
public class StoppingState extends LiftState {
//停止状态，开门，那是要的！@Overridepublic void open() {//状态修改super.context.setLiftState(Context.openningState);//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作super.context.getLiftState().open();}
@Overridepublic void close() {//虽然可以关门，但这个动作不归我执行//状态修改super.context.setLiftState(Context.closeingState);//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作super.context.getLiftState().close();}
//停止状态再跑起来，正常的很@Overridepublic void run() {//状态修改super.context.setLiftState(Context.runningState);//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作super.context.getLiftState().run();}
//停止状态是怎么发生的呢？当然是停止方法执行了@Overridepublic void stop() {System.out.println("电梯停止了...");}
}

//关闭状态
public class ClosingState extends LiftState {
@Override//电梯门关闭，这是关闭状态要实现的动作public void close() {System.out.println("电梯门关闭...");}
//电梯门关了再打开，逗你玩呢，那这个允许呀@Overridepublic void open() {super.context.setLiftState(Context.openningState);super.context.open();}

//电梯门关了就跑，这是再正常不过了@Overridepublic void run() {super.context.setLiftState(Context.runningState);super.context.run();}
//电梯门关着，我就不按楼层@Overridepublic void stop() {super.context.setLiftState(Context.stoppingState);super.context.stop();}
}

//环境角色
public class Context {//定义出所有的电梯状态public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行

//定义一个当前电梯状态private LiftState liftState;
public LiftState getLiftState() {return this.liftState;}
public void setLiftState(LiftState liftState) {//当前环境改变this.liftState = liftState;//把当前的环境通知到各个实现类中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();}
}

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