1 概述
定义: 对有状态的对象,把复杂的“判断逻辑”提取到不同的状态对象中,允许状态对象在其内部状态发生改变时改变其行为。
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 {
// 开启当然可以关闭了,我就想测试一下电梯门开关功能
@Override
public void open() {
System.out.println("电梯门开启...");
}
@Override
public void close() {
// 状态修改
super.context.setLiftState(Context.closeingState);
// 动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().close();
}
// 电梯门不能开着就跑,这里什么也不做
@Override
public void run() {
}
// 开门状态已经是停止的了
@Override
public void stop() {
}
}
运行状态类
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.stoppingState);
super.context.stop();
}
}
停止状态类
public class StoppingState extends LiftState {
// 停止状态,开门,那是要的!
@Override
public void open() {
// 状态修改
super.context.setLiftState(Context.openningState);
// 动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().open();
}
// 虽然可以关门,但这个动作不归我执行
@Override
public void close() {
// 状态修改
super.context.setLiftState(Context.closeingState);
// 动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().close();
}
// 停止状态再跑起来,正常的很
@Override
public void run() {
// 状态修改
super.context.setLiftState(Context.runningState);
// 动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().run();
}
// 停止状态是怎么发生的呢?当然是停止方法执行了
@Override
public void stop() {
System.out.println("电梯停止了...");
}
}
关闭状态类
public class ClosingState extends LiftState {
@Override
// 电梯门关闭,这是关闭状态要实现的动作
public void close() {
System.out.println("电梯门关闭...");
}
// 电梯门关了再打开,逗你玩呢,那这个允许呀
@Override
public void open() {
super.context.setLiftState(Context.openningState);
super.context.open();
}
// 电梯门关了就跑,这是再正常不过了
@Override
public void run() {
super.context.setLiftState(Context.runningState);
super.context.run();
}
// 电梯门关着,我就不按楼层
@Override
public 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();
}
}
/*
运行结果:
电梯门开启...
电梯门关闭...
电梯正在运行...
电梯停止了...
*/
4 使用场景
使用场景
- 当一个对象的行为取决于它的状态,并且它必须在运行时根据状态改变它的行为时,就可以考虑使用状态模式。
- 一个操作中含有庞大的分支结构,并且这些分支决定于对象的状态时。
优缺点
- 优点
- 将所有与某个状态有关的行为放到一个类中,并且可以方便地增加新的状态,只需要改变对象状态即可改变对象的行为。
- 允许状态转换逻辑与状态对象合成一体,而不是某一个巨大的条件语句块。
- 缺点
- 状态模式的使用必然会增加系统类和对象的个数。
- 状态模式的结构与实现都较为复杂,如果使用不当将导致程序结构和代码的混乱。
- 状态模式对"开闭原则"的支持并不太好。