“欢迎准时准点收看俗到掉渣的《小Y讲堂》节目，大家好，我是小Y,一个集性感毛发与才华于一身的程序猿。很多小伙伴应该都有同感：主人公只身英勇炸炮楼的情节在抗日题材的影视节目中可谓是习空见惯，情节的魅力点在于主人公扛炸药包、放置、离开、点火这一过程中的每一个环节都环环相扣，扣人心弦，让人情绪起伏不定。如果有人此刻问小Y看到这种情节电影心里会联想到什么？那不是废话吗？当然是《小Y讲堂》这次要讲的主题——状态模式！！”
一、状态模式的概念
状态模式定义
当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。
使用场景
- 行为随状态的改变而改变。
- 如果需要使用大量的条件、分支判断。
角色介绍
状态模式通用UML
-
State抽象状态角色
接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。
-
ConcreteState具体状态角色
具体状态主要有两个职责：一是处理本状态下的事情，二是从本状态如何过渡到其他状态。
-
Context环境角色
定义客户端需要的接口，并且负责具体状态的切换。
二、小Y炸炮楼
排长：上面给我们的指示就是不惜一切代价炸掉鬼子的炮楼，大家能不能完成任务？
众战士：誓死完成任务。
排长：很好，小Y，扛上炸药包,把炸药包放到炮楼底下，然后立马离开回来，然后我们炸它狗日的，不要怂，我们掩护你。
小Y：。。。。
1.炸炮楼过程状态UML图
炸炮楼过程状态UML
2.执行任务
①先定义炸炮楼每个阶段要做的事情
public abstract class LinkState{
protected Context context;
public void setContext(Context context){
this.context = context;
}
//扛炸药包
public abstract void carry();
//放置炸药包
public abstract void put();
//跑路
public abstract void goaway();
//点燃炸药包
public abstract void ignite();
}
②扛上炸药玩命跑路到炮楼底下
public class CarryingState extends LinkState{
@Override
public void carry() {
System.out.println("小Y:报告排长，我已跑到炮楼底下");
}
@Override
public void put() {
super.context.setLinkState(Context.puttingState);
super.context.getLinkState().put();
}
@Override
public void goaway() {
System.out.println("小Y:还没放置炸药成功，撤离失败");
}
@Override
public void ignite() {
System.out.println("小Y:还没放置炸药成功，引爆失败");
}
}
③把炸药放置在炮楼底下
public class PuttingState extends LinkState{
@Override
public void carry() {
System.out.println("小Y:还在敌方区，无法再扛炸药包");
}
@Override
public void put() {
System.out.println("小Y:好险，成功把放置炸药包");
}
@Override
public void goaway() {
super.context.setLinkState(Context.goawayingState);
super.context.getLinkState().goaway();
}
@Override
public void ignite() {
System.out.println("小Y:还没逃离敌方区，无法引爆炸药");
}
}
④放置好炸药还不赶紧跑路，等被炸药炸啊？
public class GoAwayingState extends LinkState{
@Override
public void carry() {
System.out.println("小Y:已经逃离，无法再扛炸药包");
}
@Override
public void put() {
System.out.println("小Y:已经逃离，无法进行炸药包放置");
}
@Override
public void goaway() {
System.out.println("小Y:呼~~，终于捡回条小命");
}
@Override
public void ignite() {
super.context.setLinkState(Context.ignitingState);
super.context.getLinkState().ignite();
}
}
⑤小Y成功逃离，赶紧引爆啊
public class IgnitingState extends LinkState{
@Override
public void carry() {
System.out.println("炮楼没彻底倒下，小Y继续扛炸药");
super.context.setLinkState(Context.carryingState);
super.context.getLinkState().carry();
}
@Override
public void put() {
System.out.println("小Y:炸药已引爆，无须进行炸药包放置");
}
@Override
public void goaway() {
System.out.println("小Y:炸药已引爆，早已撤离");
}
@Override
public void ignite() {
System.out.println("小Y:炸楼完成，准备加薪晋职");
}
}
⑥负责切换炸楼每个阶段的状态
public class Context {
//定义炸楼所有状态
public final static CarryingState carryingState = new CarryingState();
public final static PuttingState puttingState = new PuttingState();
public final static GoAwayingState goawayingState = new GoAwayingState();
public final static IgnitingState ignitingState = new IgnitingState();
//设置当前状态
private LinkState linkState;
public LinkState getLinkState() {
return linkState;
}
public void setLinkState(LinkState linkState) {
this.linkState= linkState;
//把当前的所处的状态通知到各个实现类中
this.linkState.setContext(this);
}
public void carry(){
this.linkState.carry();
}
public void put(){
this.linkState.put();
}
public void goaway(){
this.linkState.goaway();
}
public void ignite(){
this.linkState.ignite();
}
}
⑦炸楼执行
public class Client {
public static void main(String[] args) {
Context context = new Context();
context.setLinkState(Context.carryingState);
context.carry();
context.ignite();
context.put();
context.goaway();
context.ignite();
}
}
输出的结果为：
①小Y:报告排长，我已跑到炮楼底下
②小Y:还没放置炸药成功，引爆失败
③小Y:好险，成功把放置炸药包
④小Y:呼~~，终于捡回条小命
⑤小Y:炸楼完成，准备加薪晋职
三、总结分析
①定义了一个LinkState抽象类，声明了一个Context变量，这个是串联各个状态的封装类。封装的目的很明显，就是环节状态对象内部状态的变化不被调用类知晓，符合迪米特法则。
②Context环境角色具有两个不成文的约束：一是有几个状态对象就声明几个静态常量；二是具有状态抽象角色定义的所有行为，具体执行使用委托的方式。
③每个具体状态角色所要做的事情就是处理本状态下所对应的动作，不属于本状态处理的行为，就会切换状态并把该行为委托给负责该行为的状态。
④各个状态可以相互切换。
状态模式的优点
- 体现了开闭原则和单一职责原则，每个状态都是一个子类，你要增加状态就要增加子类，你要修改状态，你只修改一个子类就可以了。
- 符合迪米特法则。
- 封装性非常好
- 结构清晰，避免了过多的switch...case或者if...else语句的使用，避免了程序的复杂性，提高可维护性。
