码迷，mamicode.com
首页 > 其他好文 > 详细

状态机模式

时间：2015-11-09 22:18:45      阅读：271      评论：0      收藏：0      [点我收藏+]

标签：

现在需要你做一个简单是视频播放器的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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    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 sourceprint?
    1.@Override
    2.public void showAD() {
    3.System.out.println(‘show AD!‘);
    4.}

    　　现在增加一个ADState

    view sourceprint?
    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 sourceprint?
    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.适当的画出系统的状态转换图，可以更清晰地实现系统状态机。

延伸阅读：

状态机模式

标签：

原文地址：http://www.cnblogs.com/zhangchenliang/p/4951232.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！