写在前面
- 记录学习设计模式的笔记
- 提高对设计模式的灵活运用
学习地址
https://www.bilibili.com/vide...
https://www.bilibili.com/vide...
参考文章
http://c.biancheng.net/view/1...
项目源码
https://gitee.com/zhuang-kang/DesignPattern
25，状态模式
25.1 状态模式的定义和特点
状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
状态模式是一种对象行为型模式，其主要优点如下。
- 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
- 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
- 状态类职责明确，有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。
状态模式的主要缺点如下。
- 状态模式的使用必然会增加系统的类与对象的个数。
- 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。
- 状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，而且修改某个状态类的行为也需要修改对应类的源码。
25.2 状态模式的结构与实现
【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作
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;
@Override
public void setState(int state) {
this.state = state;
}
//执行关门动作
@Override
public 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;
}
}
//执行开门动作
@Override
public void open() {
switch (this.state) {
case OPENING_STATE://门已经开了，不能再开门了
//do nothing
break;
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;
}
}
//执行运行动作
@Override
public void run() {
switch (this.state) {
case OPENING_STATE://电梯不能开着门就走
//do nothing
break;
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;
}
}
//执行停止动作
@Override
public void stop() {
switch (this.state) {
case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
//do nothing
break;
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 nothing
break;
}
}
}
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也是一样)，使程序的可阅读性变差。
- 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑
25.2.1 状态模式的结构
- 环境（Context）角色：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
- 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
- 具体状态（Concrete State）角色：实现抽象状态所对应的行为。
25.2.2 代码实现
关系类图
LiftState
package com.zhuang.state.after;
/**
* @Classname LiftState
* @Description 抽象状态类
* @Date 2021/3/31 10:50
* @Created by dell
*/
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
package com.zhuang.state.after;
/**
* @Classname Context
* @Description 定义所有电梯门状态
* @Date 2021/3/31 10:53
* @Created by dell
*/
public class Context {
//定义出所有的电梯状态
//开门状态，这时候电梯只能关闭
public final static OpeningState OPENNING_STATE = new OpeningState();
//关闭状态，这时候电梯可以运行、停止和开门
public final static ClosingState CLOSEING_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 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();
}
}OpeningState
package com.zhuang.state.after;
/**
* @Classname OpeningState
* @Description 开启状态
* @Date 2021/3/31 10:51
* @Created by dell
*/
public class OpeningState extends LiftState {
//开启当然可以关闭了，我就想测试一下电梯门开关功能
@Override
public void open() {
System.out.println("电梯门开启...");
}
@Override
public void close() {
//状态修改
super.context.setLiftState(Context.CLOSEING_STATE);
//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().close();
}
//电梯门不能开着就跑，这里什么也不做
@Override
public void run() {
//do nothing
}
//开门状态已经是停止的了
@Override
public void stop() {
//do nothing
}
}ClosingState
package com.zhuang.state.after;
/**
* @Classname ClosingState
* @Description 关闭状态
* @Date 2021/3/31 10:52
* @Created by dell
*/
public class ClosingState extends LiftState {
@Override
//电梯门关闭，这是关闭状态要实现的动作
public void close() {
System.out.println("电梯门关闭...");
}
//电梯门关了再打开，逗你玩呢，那这个允许呀
@Override
public void open() {
super.context.setLiftState(Context.OPENNING_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
package com.zhuang.state.after;
/**
* @Classname RunningState
* @Description 运行状态
* @Date 2021/3/31 10:52
* @Created by dell
*/
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.OPENNING_STATE);
super.context.stop();
}
}StoppingState
package com.zhuang.state.after;
/**
* @Classname StoppingState
* @Description 停止状态
* @Date 2021/3/31 10:51
* @Created by dell
*/
public class StoppingState extends LiftState {
@Override
public void open() {
//状态修改
super.context.setLiftState(Context.OPENNING_STATE);
//动作委托给CloseState来执行 也就是委托给了ClosingState子类执行动作
super.context.getLiftState().open();
}
@Override
public void close() {
//状态修改
super.context.setLiftState(Context.CLOSEING_STATE);
//动作委托给CloseState来执行 也就是委托给了ClosingState子类执行动作
super.context.getLiftState().close();
}
@Override
public void run() {
//状态修改
super.context.setLiftState(Context.RUNNING_STATE);
//动作委托给CloseState来执行 也就是委托给了ClosingState子类执行动作
super.context.getLiftState().run();
}
@Override
public void stop() {
System.out.println("电梯停止了...");
}
}Client
package com.zhuang.state.after;
/**
* @Classname Client
* @Description 状态模式 测试类
* @Date 2021/3/31 10:53
* @Created by dell
*/
public class Client {
public static void main(String[] args) {
//开门状态
System.out.println("开门状态-->");
Context context1 = new Context();
context1.setLiftState(new OpeningState());
context1.open();
context1.close();
context1.run();
context1.stop();
System.out.println("=========================");
//关门状态
System.out.println("关门状态-->");
Context context2 = new Context();
context2.setLiftState(new ClosingState());
context2.open();
context2.close();
context2.run();
context2.stop();
System.out.println("=========================");
//运行状态
System.out.println("运行状态-->");
Context context3 = new Context();
context3.setLiftState(new RunningState());
context3.open();
context3.close();
context3.run();
context3.stop();
System.out.println("=========================");
//停止状态
System.out.println("停止状态-->");
Context context4 = new Context();
context4.setLiftState(new StoppingState());
context4.open();
context4.close();
context4.run();
context4.stop();
}
}
25.3 状态模式应用场景
- 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
- 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
写在最后
- 如果我的文章对你有用，请给我点个👍，感谢你😊！
- 有问题，欢迎在评论区指出！💪
java
程序员
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。