这是我参与8月更文挑战的第5天，活动详情查看：8月更文挑战
什么是状态模式（State）
概念
状态模式（State Pattern）属于行为型模式，定义：一个对象的行为由其内部的状态决定。
要想学习状态模式，那就一定要提到状态机了，状态机又是什么？状态机就是列举出一个东西的多种状态，研究这几种状态的切换行为，然后绘制成一个可以连通的状态图。
这里以门闸为例，在广州地铁里，我们过完安检后，想要进入到地铁内部的话就需要刷卡过门闸，这里的闸门就有很多种状态，未刷卡前是关闭状态，我们无法通过闸门；刷卡后会有一个中间状态：处理中状态，这个状态，我们已经刷了卡，但机器还在处理，没有把门打开，我们也无法通过；处理完成后就变成了打开状态，我们可以通过，通过后就变成了关闭状态。在这个过程中，闸门有三种状态：关闭、处理中、打开，我们需要跟闸门进行交互的行为：刷卡、通过，下面我画一个状态图：
我在学习的时候发现，这个状态模式的实现跟策略模式的几乎一毛一样。
可以说状态模式是策略模式的衍生版，虽然他们的实现是一模一样的，但是解决的问题却是不一样的。策略模式是把算法封装起来，让这些算法可以相互替换，提高代码的复用性；而状态模式完完全全就是围绕着状态机来的，提供了一个状态机的实现方式，状态模式才能说减少了因判断当前状态的if-else和switch的使用，后面会做一下演示。
优点
- 状态对象封装了状态的转换规则，减少了判断语句的使用。
- 不同的环境对象可以共用状态对象，减少了对象的个数。
- 符合单一职责原则。分离出不同的状态和行为，让每个状态类的职责更加清晰，有利于系统的扩展。
缺点
- 没有遵守开放封闭原则。如果新增了新的状态，想要使用这个状态，就要在旧的状态类中加上转换到新状态的逻辑。
- 设计与实现比较复杂。
原则
“+”代表遵守，“-”代表不遵守或者不相关
| 原则 | 开放封闭 | 单一职责 | 迪米特 | 里氏替换 | 依赖倒置 | 接口隔离 | 合成复用 |
|---|---|---|---|---|---|---|---|
| - | + | - | - | + | - | - | |
适用场景
- 当一个对象的行为取决于它的状态。
- 需要大量判断或分支语句的情况。
如何实现
想要实现状态模式，需要以下三样东西：
- 环境抽象类（Abstract Context）：它需要定义与用户交互的方法，并且有一个状态对象，所有的方法都委托给这个状态对象来实现
- 环境（Context）类：实现环境抽象类，并且扩展其他功能。
- 状态（State）接口/抽象类：定义状态的行为，这些行为和环境类的一致，还需要实现状态切换的逻辑。
- 具体状态（Concrete State）类：实现抽象状态接口/抽象类，实现状态转换逻辑。
类图
例子
这里以前面的闸门为例，闸门的三种状态：关闭、处理中、打开，跟闸门进行交互的行为：刷卡、通过。
不用状态模式的例子
这里简单写一下不用状态模式实现会是怎么样的：
/**
* 不使用状态模式实现的闸门
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class NoUserStatePatternGate {
//当前状态，初始状态为关闭状态
private String currentState=CLOSE_STATE;
//关闭状态
private static String CLOSE_STATE="closed";
//打开状态
private static String OPEN_STATE="open";
//处理中
private static String PROCESSING="processing";
/**
* 刷卡
*/
public void pay(){
if (this.currentState.equals(CLOSE_STATE)){
//当前是关闭，刷卡应该转为处理中
System.out.println("刷卡成功，正在处理");
//转为正在处理状态
this.currentState=PROCESSING;
Random random=new Random();
//模拟出现故障
if (random.nextBoolean()){
processSuccess();
}else {
processFail();
}
return;
}
if (this.currentState.equals(PROCESSING)){
System.out.println("请稍等。。正在处理");
return;
}
if (this.currentState.equals(OPEN_STATE)){
System.out.println("闸门已经打开了，请通过");
return;
}
}
/**
* 通过
*/
public void pass(){
if (this.currentState.equals(CLOSE_STATE)){
System.out.println("无法通过，请刷卡");
return;
}
if (this.currentState.equals(PROCESSING)){
System.out.println("请稍等。。正在处理");
return;
}
if (this.currentState.equals(OPEN_STATE)){
System.out.println("已通过，闸门关闭");
this.currentState=CLOSE_STATE;
return;
}
}
/**
* 处理失败
*/
private void processFail(){
System.out.println("处理失败！");
//转回关闭状态
this.currentState=CLOSE_STATE;
}
/**
* 处理成功
*/
private void processSuccess(){
System.out.println("处理成功！");
//转到打开状态
this.currentState=OPEN_STATE;
}
}
测试：
/**
* 状态模式测试
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class StateTest {
public static void main(String[] args) {
NoUserStatePatternGate gate=new NoUserStatePatternGate();
gate.pass();
gate.pay();
gate.pay();
gate.pass();
gate.pay();
gate.pass();
gate.pay();
gate.pass();
gate.pay();
gate.pass();
/**
* 结果：
* 无法通过，请刷卡
* 刷卡成功，正在处理
* 处理成功！
* 闸门已经打开了，请通过
* 已通过，闸门关闭
* 刷卡成功，正在处理
* 处理成功！
* 已通过，闸门关闭
* 刷卡成功，正在处理
* 处理失败！
* 无法通过，请刷卡
* 刷卡成功，正在处理
* 处理失败！
* 无法通过，请刷卡
*/
}
}
基本功能实现了，减去了支付扣钱这些操作，如果你想实现的话，可以拷贝下去补充。
这里的if-else不是一般的多啊，改成switch会好一点，不过还是会让整个代码变得非常的麻烦，如果以后想要再加新增状态，就只能继续加if-else了，逻辑也非常的混乱，多加几个状态后，可能就不是普通人所能驾驭的了，下面来看看使用状态模式是如何实现的。
使用状态模式
代码有那么一点复杂，加了一个共享状态对象，其他的就是把这些判断当前状态的if-else去掉了，每个if-else的逻辑操作都分散到状态类中了。
类图
这个类图有那么一丢丢乱，没办法，状态模式实现起来有点复杂，不过每个类的职责都很清晰的，结合后面的代码来看。
环境类
环境抽象类
/**
* 环境抽象类
* 闸门抽象类
*
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public abstract class AbstractGate {
/**
* 闸门状态
*/
protected AbstractGateState state;
/**
* 因为这一部分的代码都是一样的
* 所以这里写到抽象方法中了
*/
/**
* 刷卡
*/
public void pay() {
this.state.pay(this);
}
/**
* 通过
*/
public void pass() {
this.state.pass(this);
}
public AbstractGateState getState() {
return state;
}
protected AbstractGate setState(AbstractGateState state) {
this.state = state;
return this;
}
}
具体环境类
/**
* 环境类
* 地铁闸门
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class SubwayGate extends AbstractGate{
public SubwayGate(){
//默认关闭
this(false);
}
public SubwayGate(boolean isOpen){
//可以通过构件方法设置是否开启闸门
Class stateClass;
if (isOpen){
stateClass= OpenState.class;
}else {
stateClass=ClosedState.class;
}
this.state=AbstractGateState.getState(stateClass);
}
}
状态类
状态抽象类
/**
* 状态抽象类
* 闸门状态
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public abstract class AbstractGateState {
private static Map<Class,AbstractGateState> stateMap=new HashMap<>();
/**
* 刷卡
*/
public abstract void pay(AbstractGate gate);
/**
* 通过
*/
public abstract void pass(AbstractGate gate);
/**
* 这里写一个空方法
* 主要是考虑到处理状态是一个中间的瞬时的状态，需要完成一定的处理逻辑
* 如果只是切换状态的话，就无法触发处理逻辑，环境类只与用户交互两个动作：pay、pass，无法触发“处理中状态”的处理逻辑
* @throws IllegalAccessException
*/
public void handle(AbstractGate gate) throws IllegalAccessException {
throw new IllegalAccessException();
}
/**
* 用这个方法来获取状态对象，实现状态对象的共用
* @param stateClass
* @return
*/
protected static final AbstractGateState getState(Class stateClass){
AbstractGateState state = stateMap.get(stateClass);
//双重校验
if (state==null){
synchronized (AbstractGateState.class){
state = stateMap.get(stateClass);
if (state==null){
try {
state= (AbstractGateState) stateClass.newInstance();
stateMap.put(stateClass,state);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
return state;
}
}
关闭状态
/**
* 具体状态类
* 关闭状态
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class ClosedState extends AbstractGateState {
@Override
public void pay(AbstractGate gate) {
//当前是关闭，刷卡应该转为处理中
System.out.println("刷卡成功，正在处理");
//设置为处理中状态
AbstractGateState processingState = getState(ProcessingState.class);
gate.setState(processingState);
try {
processingState.handle(gate);
} catch (IllegalAccessException e) {
}
}
@Override
public void pass(AbstractGate gate) {
System.out.println("无法通过，请刷卡");
}
}
处理中状态
/**
* 具体状态类
* 处理中状态
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class ProcessingState extends AbstractGateState {
//模拟出现故障概率
private Random random = new Random();
@Override
public void pay(AbstractGate gate) {
System.out.println("请稍等。。正在处理");
return;
}
@Override
public void pass(AbstractGate gate) {
System.out.println("请稍等。。正在处理");
return;
}
@Override
public void handle(AbstractGate gate) throws IllegalAccessException {
//转为正在处理状态
if (random.nextBoolean()) {
System.out.println("处理失败！");
gate.setState(getState(ClosedState.class));
} else {
System.out.println("处理成功！");
gate.setState(getState(OpenState.class));
}
}
}
打开状态
/**
*
* 具体状态类
* 打开状态
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class OpenState extends AbstractGateState {
@Override
public void pay(AbstractGate gate) {
System.out.println("闸门已经打开了，请通过");
return;
}
@Override
public void pass(AbstractGate gate) {
System.out.println("已通过，闸门关闭");
//设置为关闭状态
gate.setState(getState(ClosedState.class));
return;
}
}
测试
/**
* 状态模式测试
* Created on 2021/6/15.
*
* @author xuxiaobai
*/
public class StateTest {
public static void main(String[] args) {
AbstractGate gate=new SubwayGate();
gate.pass();
gate.pay();
gate.pay();
gate.pay();
gate.pay();
gate.pass();
gate.pay();
gate.pass();
gate.pay();
gate.pass();
gate.pay();
gate.pass();
/**
* 结果：
* 无法通过，请刷卡
* 刷卡成功，正在处理
* 处理成功！
* 闸门已经打开了，请通过
* 已通过，闸门关闭
* 刷卡成功，正在处理
* 处理成功！
* 已通过，闸门关闭
* 刷卡成功，正在处理
* 处理失败！
* 无法通过，请刷卡
* 刷卡成功，正在处理
* 处理失败！
* 无法通过，请刷卡
*/
}
}
这里的处理是否通过是有概率的，所以每次结果都会不一样。
写到这里就结束了，你都看到这了，还不给我点个赞？
总结
虽说状态模式是策略模式的衍生版，但它们在使用上不会存在太大的差别，唯一需要注意的就是它们俩的思维逻辑不同，策略模式只关注把算法、逻辑等等封装到一个类中，而状态模式是把算法与逻辑和状态一起封装到一个类中，状态模式是离不开状态的，可以说状态模式包含策略模式。
——————————————————————————————
你知道的越多，不知道的就越多。
如果本文章内容有问题，请直接评论或者私信我。如果觉得我写得还不错的话，点个赞也是对我的支持哦
未经允许，不得转载！
