状态模式(State Pattern) —— 让你的对象学会72变

状态模式(State Pattern) —— 让你的对象学会72变

当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。

一、怎么理解一个对象有多个状态？

一个对象和多个状态关联，每种状态又对应一种行为，也就是同一个对象会因为状态不同让你觉得这是不是同一个类。

比如，手机的HOME键：

关机状态: 没有反应。开机后首次启动: 密码解锁。非首次启动: 密码解锁或者指纹解锁。启动后：返回主页面。

这里因为手机状态的不同，HOME键就有不同的功能或者行为。

同样是HOME键给人们的感觉好像是好多的按键，好像不再是同一个类。

也就是说对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

二、怎么去实现？

上面的对象因为状态不同而出现不同行为的场景怎么去实现？

你可能会想到 if/else 那种方式去实现，代码中包含大量与对象状态有关的条件语句，满足不同的条件就选择执行对应的行为。

但这种方式在介绍 策略模式的时候也说过它的缺点，难维护、难扩展，违背开闭原则。

使用状态模式就可以很好的规避这个问题，状态模式将各种具体的状态类抽象出来，把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。这段红色的字已经说清楚了状态模式的实现方式：

抽象状态类：

abstract class State { public abstract void Handle(Context context);}

具体状态类：

/** * 具体状态类 A */class ConcreteStateA extends State { public void Handle(Context context) { System.out.println("当前状态是 A."); // 改变状态 context.setState(new ConcreteStateB()); }}

/** * 具体状态类 B */class ConcreteStateB extends State { public void Handle(Context context) { System.out.println("当前状态是 B."); // 改变状态 context.setState(new ConcreteStateA()); }}

上下文环境类：

class Context { private State state; //定义环境类的初始状态 public Context(State state) { this.state = state; } //设置新状态 public void setState(State state) { this.state = state; } //读取状态 public State getState() { return (state); } //对请求做处理 public void Handle() { state.Handle(this); }}

public class Client { public static void main(String[] args) { State state = new ConcreteStateA(); //创建环境 Context context = new Context(state); //处理请求 context.Handle(); context.Handle(); context.Handle(); context.Handle(); }}

三、用“状态模式”设计一个多线程的状态转换程序

现在先定义一个抽象状态类（TheadState），然后为上图的每个状态设计一个具体状态类，它们是新建状态（New）、就绪状态（Runnable ）、运行状态（Running）、阻塞状态（Blocked）和死亡状态（Dead），每个状态中有触发它们转变状态的方法，环境类（ThreadContext）中先生成一个初始状态（New），并提供相关触发方法，下图所示是线程状态转换程序的结构图：

abstract class ThreadState { //状态名 protected String stateName;}

//具体状态类：新建状态class New extends ThreadState { public New() { stateName = "新建状态"; System.out.println("当前线程处于：新建状态."); } public void start(ThreadContext context) { System.out.print("调用start()方法-->"); if (stateName.equals("新建状态")) { // 启动新线程，并改变状态 context.setState(new Runnable()); } else { System.out.println("当前线程不是新建状态，不能调用start()方法."); } }}

//具体状态类：就绪状态class Runnable extends ThreadState { public Runnable() { stateName = "就绪状态"; System.out.println("当前线程处于：就绪状态."); } public void getCPU(ThreadContext context) { System.out.print("获得CPU时间-->"); if (stateName.equals("就绪状态")) { // 改变状态 —— 变成运行状态 context.setState(new Running()); } else { System.out.println("当前线程不是就绪状态，不能获取CPU分片."); } }}

//具体状态类：运行状态class Running extends ThreadState { public Running() { stateName = "运行状态"; System.out.println("当前线程处于：运行状态."); } public void suspend(ThreadContext context) { System.out.print("调用suspend()方法-->"); if (stateName.equals("运行状态")) { context.setState(new Blocked()); } else { System.out.println("当前线程不是运行状态，不能调用suspend()方法."); } } public void stop(ThreadContext context) { System.out.print("调用stop()方法-->"); if (stateName.equals("运行状态")) { context.setState(new Dead()); } else { System.out.println("当前线程不是运行状态，不能调用stop()方法."); } }}

//具体状态类：阻塞状态class Blocked extends ThreadState { public Blocked() { stateName = "阻塞状态"; System.out.println("当前线程处于：阻塞状态."); } public void resume(ThreadContext context) { System.out.print("调用resume()方法-->"); if (stateName.equals("阻塞状态")) { context.setState(new Runnable()); } else { System.out.println("当前线程不是阻塞状态，不能调用resume()方法."); } }}

//具体状态类：死亡状态class Dead extends ThreadState { public Dead() { stateName = "死亡状态"; System.out.println("当前线程处于：死亡状态."); }}

class ThreadContext { private ThreadState state; ThreadContext() { state = new New(); } public void setState(ThreadState state) { this.state = state; } public ThreadState getState() { return state; } public void start() { ((New) state).start(this); } public void getCPU() { ((Runnable) state).getCPU(this); } public void suspend() { ((Running) state).suspend(this); } public void stop() { ((Running) state).stop(this); } public void resume() { ((Blocked) state).resume(this); } public void startWork (){ this.start(); this.getCPU(); this.suspend(); this.resume(); this.getCPU(); this.stop(); }}

public class Client { public static void main(String[] args) { ThreadContext context = new ThreadContext(); context.startWork(); }}

当前线程处于：新建状态.调用start()方法-->当前线程处于：就绪状态.获得CPU时间-->当前线程处于：运行状态.调用suspend()方法-->当前线程处于：阻塞状态.调用resume()方法-->当前线程处于：就绪状态.获得CPU时间-->当前线程处于：运行状态.调用stop()方法-->当前线程处于：死亡状态.

四、适用场景

优点

状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

缺点

状态模式的使用必然会增加系统的类与对象的个数。状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

应用场景

通常在以下情况下可以考虑使用状态模式。

当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。