状态机模式

最新推荐文章于 2023-07-25 17:16:45 发布
最新推荐文章于 2023-07-25 17:16:45 发布
阅读量159 收藏
点赞数
文章标签： 设计模式 c# java
原文链接：http://www.cnblogs.com/zhangchenliang/p/4951232.html
版权

现在需要你做一个简单是视频播放器的APP，主要有播放，暂停，停止三个功能，在没学状态机模式之前，你可能会这样来实现：

现抽象个IPlayer接口，定义好你的播放器需要实现的动作和可能的状态字段：

 

  • 01. 1 public interface IPlayer {
    02. 2     public static final int STATE_PLAYING = 1;
    03. 3     public static final int STATE_PAUSED = 2;
    04. 4     public static final int STATE_STOPPED = 3;
    05. 5
    06. 6     public void palyVedio();
    07. 7
    08. 8     public void pause();
    09. 9
    10. 10     public void stop();
    11. 11 }
    IPlayer

    现在就可以实现IPlayer接口了：

    view source print ?
    01. 1 public class VedioPlayer implements IPlayer {
    02. 2     public int mCurrentState;
    03. 3
    04. 4     @Override
    05. 5     public void palyVedio() {
    06. 6         switch (mCurrentState) {
    07. 7         case STATE_PLAYING:
    08. 8             System.out.println(' curent state is palying, do nothing.');
    09. 9         case STATE_PAUSED:
    10. 10         case STATE_STOPPED:
    11. 11             System.out.println('paly vedio now.');
    12. 12             break;
    13. 13         default:
    14. 14             // would it happen? who care.
    15. 15             break;
    16. 16         }
    17. 17         mCurrentState = STATE_PLAYING;
    18. 18     }
    19. 19
    20. 20     @Override
    21. 21     public void pause() {
    22. 22         switch (mCurrentState) {
    23. 23         case STATE_PLAYING:
    24. 24             System.out.println('pause vedio now');
    25. 25             break;
    26. 26         case STATE_PAUSED:
    27. 27             System.out.println(' curent state is paused, do noting.');
    28. 28         case STATE_STOPPED:
    29. 29             System.out.println('curent state is stopped,do noting.');
    30. 30             break;
    31. 31         default:
    32. 32             // would it happen? who care.
    33. 33             break;
    34. 34         }
    35. 35         mCurrentState = STATE_PAUSED;
    36. 36     }
    37. 37
    38. 38     @Override
    39. 39     public void stop() {
    40. 40         switch (mCurrentState) {
    41. 41         case STATE_PLAYING:
    42. 42         case STATE_PAUSED:
    43. 43             System.out.println(' stop vedio now.');
    44. 44         case STATE_STOPPED:
    45. 45             System.out.println('curent state is stopped,do noting.');
    46. 46             break;
    47. 47         default:
    48. 48             // would it happen? who care.
    49. 49             break;
    50. 50         }
    51. 51         mCurrentState = STATE_STOPPED;
    52. 52     }
    53. 53
    54. 54
    55. 55 }

    看着还错喔。

    我们都知道，需求总是会改变的，现在你的boss需要在视频播放中（片头或者片尾什么的）可以播放一段广告。嗯，你可能会觉得没关系，只需要在接口上增加多一个方法就好了，同时增加个状态字段，修改后：


    加载中...
    view source print ?
    01. 1 public interface IPlayer {
    02. 2     public static final int STATE_PLAYING = 1;
    03. 3     public static final int STATE_PAUSED = 2;
    04. 4     public static final int STATE_STOPPED = 3;
    05. 5     public static final int STATE_AD = 4;
    06. 6    
    07. 7     public void palyVedio();
    08. 8     public void pause();
    09. 9     public void stop();
    10. 10     public void showAD();
    11. 11 }
    IPlayer

    最后你认为只需要VedioPlayer实现增加的showAD方法就大功告成了，

    view source print ?
    01. 1     @Override
    02. 2     public void showAD() {
    03. 3         switch (mCurrentState) {
    04. 4         case STATE_AD:
    05. 5             System.out.println('curent state is AD,do noting');
    06. 6             break;
    07. 7         case STATE_PLAYING:
    08. 8             System.out.println('show advertisement now.');
    09. 9             break;
    10. 10         case STATE_PAUSED:
    11. 11             System.out.println('curent state is paused , do noting');
    12. 12         case STATE_STOPPED:
    13. 13             System.out.println('curent state is stopped ,do noting.');
    14. 14             break;
    15. 15         default:
    16. 16             // would it happen? who care.
    17. 17             break;
    18. 18         }
    19. 19         mCurrentState = STATE_AD;
    20. 20     }

    真的就完了？终于发现了，palyVedio，pause，stop三个方法中的swtich里面还需要各多加一个case的判断，纳尼！！！如果以后又增加几个状态，那么还得修改啊，而且随着状态的增加，修改的代码也会成倍的增加，简直不可想象。这种情况下，状态机模式就可以帮你个大忙了。

    状态机模式：允许对象在内部状态改变时改变它的行为，对象看起来就好像修改了它的类。\

    看着还是有点抽象吧，这里的Context就相当于我们的VedioPlayer类，我们继续以视频播放为例子：

    首先还是实现播放，暂停，停止状态，此时的状态转换图应该是这样：

    \

    还是先抽象一个IPlayer作为上下文（Context）:

    view source print ?
    01. 1 public abstract class IPlayer {
    02. 2    
    03. 3     public abstract void request(int flag);
    04. 4    
    05. 5     public abstract void setState(PlayerState state);
    06. 6    
    07. 7     public abstract void palyVedio();
    08. 8
    09. 9     public abstract void pause();
    10. 10
    11. 11     public abstract void stop();
    12. 12
    13. 13     public abstract void showAD();
    14. 14 }

    可以看到有一个setState方法，这是为了可以设置内部状态。

    有了Context，我来实现State吧，这里写成一个抽线类

    view source print ?
    01. 1 public abstract class PlayerState {
    02. 2     public final static int PLAY_OR_PAUSE=0;
    03. 3     public final static int STOP=1;
    04. 4     protected IPlayer mPlayer;
    05. 5     public PlayerState(IPlayer player) {
    06. 6         this.mPlayer=player;
    07. 7     }
    08. 8     public abstract void handle(int action);
    09. 9     @Override
    10. 10     public String toString() {
    11. 11         return 'current state:'+this.getClass().getSimpleName();
    12. 12     }
    13. 13 }

    再看State的实现，我们有播放，暂停，停止三种状态，所以需要三个实现类:


    加载中...
    view source print ?
    01. public class PlayingState extends PlayerState {
    02. public PlayingState(IPlayer player) {
    03. super(player);
    04. }
    05.  
    06. @Override
    07. public void handle(int action) {
    08. switch (action) {
    09. case PlayingState.PLAY_OR_PAUSE:
    10. mPlayer.pause();
    11. mPlayer.setState(new PausedState(mPlayer));
    12. break;
    13. case PlayerState.STOP:
    14. mPlayer.stop();
    15. mPlayer.setState(new StoppedState(mPlayer));
    16. break;
    17. default:
    18. throw new IllegalArgumentException('ERROE ACTION:'+action+',current state:'+this.getClass().getSimpleName());
    19. }
    20. }
    21. }
    PlayingState 加载中...
    view source print ?
    01. public class PausedState extends PlayerState {
    02.  
    03. public PausedState(IPlayer player) {
    04. super(player);
    05. }
    06. @Override
    07. public void handle(int action) {
    08. switch (action) {
    09. case PlayingState.PLAY_OR_PAUSE:
    10. mPlayer.palyVedio();
    11. mPlayer.setState(new PlayingState(mPlayer));
    12. break;
    13. case PlayerState.STOP:
    14. mPlayer.stop();
    15. mPlayer.setState(new StoppedState(mPlayer));
    16. break;
    17. default:
    18. throw new IllegalArgumentException('ERROE ACTION:'+action+',current state:'+this.getClass().getSimpleName());
    19. }
    20. }
    21. }
    PausedState 加载中...
    view source print ?
    01. public class StoppedState extends PlayerState {
    02.  
    03. public StoppedState(IPlayer player) {
    04. super(player);
    05. }
    06.  
    07. @Override
    08. public void handle(int action) {
    09. switch (action) {
    10. case PlayingState.PLAY_OR_PAUSE:
    11. mPlayer.palyVedio();
    12. mPlayer.setState(new PlayingState(mPlayer));
    13. break;
    14. default:
    15. throw new IllegalArgumentException('ERROE ACTION:'+action+',current state:'+this.getClass().getSimpleName());
    16. }
    17. }
    18. }
    StoppedState

    最后就是IPlayer的实现类VedioPlayer

    view source print ?
    01. public class VedioPlayer extends IPlayer {
    02. private PlayerState mState=new StoppedState(this);
    03.  
    04. @Override
    05. public void palyVedio() {
    06. System.out.println('play vedio!');
    07. }
    08.  
    09. @Override
    10. public void pause() {
    11. System.out.println('pause vedio!');
    12. }
    13.  
    14. @Override
    15. public void stop() {
    16. System.out.println('stop vedio!');
    17. }
    18.  
    19. // @Override
    20. // public void showAD() {
    21. // System.out.println('show AD!');
    22. // }
    23.  
    24. @Override
    25. public void setState(PlayerState state) {
    26. mState = state;
    27. }
    28.  
    29. @Override
    30. public void request(int action) {
    31. System.out.println('before action:' + mState.toString());
    32. mState.handle(action);
    33. System.out.println('after action:' + mState.toString());
    34. }
    35.  
    36. }

    现在的代码就简洁多了，因为VedioPlayer只需要实现需要的操作，每次接收输入的时候（request方法调用），只需要交给当前的状态去处理，而每个状态不需要知道自己之前的状态是什么，只需要知道接收到什么样的输入而做出相应的操作和下一个状态，现在来验证下正确性：

    view source print ?
    01. 1 public class Main {
    02. 2
    03. 3     /**
    04. 4      * @param args
    05. 5      */
    06. 6     public static void main(String[] args) {
    07. 7         Scanner sc=new Scanner(System.in);
    08. 8         IPlayer player=new VedioPlayer();
    09. 9         int i=-1;
    10. 10         while((i=sc.nextInt())!=-1){
    11. 11             player.request(i);
    12. 12         }
    13. 13     }
    14. 14
    15. 15 }

    依次如下输入：

    \

    最后抛出了java.lang.IllegalArgumentException: ERROE ACTION:1,current state:StoppedState，因为在stopped状态下，又再次尝试stop，具体可以看StoppedState的实现。从流程来看，也验证了程序的正确性。

    现在我们为视频播放器添加一个播放广告的状态，此时系统的状态：

    \

    　　上面我们提到VedioPlayer只需要实现需要的操作，每次接收输入的时候（request方法调用），只需要交给当前的状态去处理。

    　　也就是说现在的VedioPlayer再实现一个showAD的操作就可以了，剩下的就是状态们之间的事了。

    view source print ?
    1. @Override
    2. public void showAD() {
    3. System.out.println('show AD!');
    4. }

    　　现在增加一个ADState

    view source print ?
    01. public class ShowADState extends PlayerState {
    02. public ShowADState(IPlayer player) {
    03. super(player);
    04. }
    05. @Override
    06. public void handle(int action) {
    07. switch (action) {
    08. case PlayingState.PLAY_OR_PAUSE:
    09. mPlayer.palyVedio();
    10. mPlayer.setState(new PlayingState(mPlayer));
    11. break;
    12. default:
    13. throw new IllegalArgumentException('ERROE ACTION:'+action+','+this.toString());
    14. }
    15. }
    16.  
    17. }

    现在依然还没有完事，前面提到，每个状态不需要知道自己之前的状态是什么，只需要知道接收到什么样的输入而做出相应的操作和下一个状态。

    由状态图可以看到，PlayingState的下一个状态增加了一个ShowADState，所以PlayingState还需要做一点修改，如下：

    view source print ?
    01. 1 public class PlayingState extends PlayerState {
    02. 2     public PlayingState(IPlayer player) {
    03. 3         super(player);
    04. 4     }
    05. 5
    06. 6     @Override
    07. 7     public void handle(int action) {
    08. 8         switch (action) {
    09. 9         case PlayingState.PLAY_OR_PAUSE:
    10. 10             mPlayer.pause();
    11. 11             mPlayer.setState(new PausedState(mPlayer));
    12. 12             break;
    13. 13         case PlayerState.STOP:
    14. 14             mPlayer.stop();
    15. 15             mPlayer.setState(new StoppedState(mPlayer));
    16. 16             break;
    17. 17         case PlayingState.SHOW_AD:
    18. 18             mPlayer.showAD();
    19. 19             mPlayer.setState(new ShowADState(mPlayer));
    20. 20             break;
    21. 21         default:
    22. 22             throw new IllegalArgumentException('ERROE ACTION:'+action+',current state:'+this.getClass().getSimpleName());
    23. 23         }
    24. 24     }
    25. 25 }

    增加了17到20行的代码。

    再来验证程序：

    \

    同样可以正确的运行。也可以看出，对于状态的增加，所带来的修改成本比没用状态机模式要小的多，特别对于状态更多的程序。

    至此状态机模式也讲完了。

    总结：

    1.状态机模式：允许对象在内部状态改变时改变它的行为，对象看起来就好像修改了它的类（每个状态可以做出不一样的动作）；

    2.拥有多个状态的对象（Context）只需要实现需要的操作，每次接收输入的时候（request方法调用），只需要交给当前的状态去处理，而每个状态不需要知道自己之前的状态是什么，只需要知道接收到什么样的输入（或者没输入）而做出相应的操作和自己下一个状态是什么即可；

    3.适当的画出系统的状态转换图，可以更清晰地实现系统状态机。

延伸阅读：

转载于:https://www.cnblogs.com/zhangchenliang/p/4951232.html

weixin_33841503
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
极客时间《设计模式之美》笔记---状态模式
Tattoo的博客
07-25 857
文章目录什么是有限状态机？实现方法一：分支实现法实现方法二：查表法实现方法三：状态模式 什么是有限状态机？ 有限状态机，英文翻译是Finite State Machine，缩写为FSM，简称为状态机。状态机有3个组成部分：状态（State）、事件（Event）、动作（Action）。其中，事件也称为转移条件（Transition Condition）。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作。 “超级马里奥”游戏不知道你玩过没有？在游戏中，马里奥可以变身为多种形
设计模式-状态模式
FDoubleman的博客
02-02 746
状态(机)模式学习
状态机、状态模式
Cookie__C的博客
02-09 1069
一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类状态类
设计模式-状态机模式
zbbzb的博客
02-18 1988
设计模式-状态机
设计模式——状态模式
海纳百川
03-06 322
设计模式——状态模式 一、基本概念 1. 定义 状态（State）模式：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。 状态模式是一种行为设计模式， 让你能在一个对象的内部状态变化时改变其行为， 使其看上去就像改变了自身所属的类一样。 2. 优缺点 优点： 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”； 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得
状态机延时
10-20
在FPGA开发中用到状态机，一个状态到另一个状态之间的时间控制
LabVIEW程序设计模式-消息队列型状态机模式[收集].pdf
10-19
LabVIEW程序设计模式-消息队列型状态机模式[收集].pdf
状态模式实例（电梯）
05-20
能让你迅速理解和运用设计模式中的状态模式，进行编程
状态机源码,C++
05-16
非常好的状态机源码，内附单元测试源码，使用范例源码和使用PPT
嵌入式系统中关于状态机设计经验
11-09
在使用iTRON类OS的嵌入式系统中，除了驱动程序以外，大多数模块也就是中间件和应用程序是以任务（TASK）的形式设计的。而iTRON类OS大多采用C语言实现，于是用状态机的方式实现功能模块成为了主要的设计方法。 至于说面向对象，只要是稍微严谨一点的嵌入式系统，设计上要求程序完全覆盖所有的可能情况。程序不可能在紧急情况下抛出异常等待调试。同时由于对硬件和其它应用模块的往往具有严重的耦合性，代码的重用和扩展也不是那么随心所欲。当然还有基于语言的执行速度之类的考虑。这种情况下C语言往往取代大多数现代语言成为了主角吧。下面就一起来分享一下设计心得吧！
详解设计模式：状态模式
栗筝i的博客
12-05 4766
状态模式（State Pattern）也被称为状态机模式（State Machine Pattern），是在 GoF 23 种设计模式中定义了的行为型模式。 在状态模式 类的行为是基于它的状态改变的。在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。状态模式 对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。 本篇文章内容包括：关于状态模式、状态模式 Demo
设计模式：状态机模式
weixin_62953519的博客
08-20 6866
这个就是状态机模式的精髓，因为处理的问题就是一个类的方法处理信息的模式和类的状态有关，那么换句话说技术类中的每个状态都要处理相同的信息，那么我们为什么不把这种状态抽离出来呢，然后单独考虑呢？但是，这个模式也有坏处，那就是没当添加新的状态，如果这个状态有和其他状态有转换，那么我们就不得不修改源代码，这里，本菜想，可以通过中介者模式来解决这个问题，具体方法是将。可以看到，典型的bad smell，这里我们可以将每个状态抽象出来，设计好接口，然后用多态来替代if_else。
设计模式——状态模式（State Pattern）
Lucifer ZHAO
06-04 3170
状态模式（State Pattern）又称状态机模式，是允许对象在内部状态发生改变时改变他的的行为，类的行为由状态决定，不同的状态有着不同的行为，对象看起来好像修改了它的类。属于行为型模式。一般涉及到电商订单相关的，会采用状态模式来设计，不同的订单状态，响应的都有不同的操作。 适用场景 1) 行为随状态改变而改变的场景 2) 一个操作中含有庞大的多分支结构，并且这些分支取决于对象的状态状态抽象对象.........
23种设计模式--状态模式
隔壁老王呀的专栏
11-08 1355
状态模式的解决思想是：当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，用各个不同的类进行表示，系统处于哪种情况，直接使用相应的状态类对象进行处理，这样能把原来复杂的逻辑判断简单化，消除了 if-else、switch-case 等冗余语句，代码更有层次性，并且具备良好的扩展力。 优点： 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。 将状态转换显示化，减少对象间的相互依赖。 状态类职责明确，有利于程序的扩展。通
23种设计模式之状态机模式
最新发布
qq_29581829的博客
07-25 157
状态机模式
什么是状态机？用C语言实现进程5状态模型
一口Linux的专栏
10-13 9850
前言 状态机在实际工作开发中应用非常广泛，一口君曾经做过很多网络协议模块，可以说很多协议的开发都必须用到状态机；一个健壮的状态机可以让你的程序，不论发生何种突发事件都不会突然进入一个不可预知的程序分支，本篇通过实现一个简单的进程5状态模型的状态机，让大家熟悉一下状态机的魅力。 定义 有限状态机（finite-state machine，缩写FSM），又叫有限状态机自动机，简称状态机。是能够表示有限个状态以及这些状态之间的转移和动作等行为的数学模型。在计算机科学中，有限状态机被广泛用于建模应用行为、硬件电路系
设计模式—状态机模式
热门推荐
苦行僧
08-22 1万+
文章目录1.概要定义四要素2. 状态机模式实现 1.概要 定义 状态机由状态寄存器和组合逻辑电路构成，能够根据控制信号按照预先设定的状态进行状态转移，是协调相关信号动作、完成特定操作的控制中心。（状态机是有限状态自动机的简称，是现实事物运行规则抽象而成的一个数学模型。） 四要素 State：状态。一个状态机至少要包含两个状态 Event：事件。事件就是执行某个操作的触发条件或者口令 A...
状态机模式代码
05-24
以下是一个简单的状态机模式的示例代码： ```python class State: def run(self): assert 0, "run not implemented" class StateA(State): def run(self): print("State A") return StateB() class StateB...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值