状态机模式

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

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

public interface IPlayer {
    public static final int STATE_PLAYING = 1;
    public static final int STATE_PAUSED = 2;
    public static final int STATE_STOPPED = 3;

    public void palyVedio();

    public void pause();

    public void stop();
}

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

public class VedioPlayer implements IPlayer {
    public int mCurrentState;

    @Override
    public void palyVedio() {
        switch (mCurrentState) {
        case STATE_PLAYING:
            System.out.println(" curent state is palying, do nothing.");
        case STATE_PAUSED:
        case STATE_STOPPED:
            System.out.println("paly vedio now.");
            break;
        default:
            // would it happen? who care.
            break;
        }
        mCurrentState = STATE_PLAYING;
    }

    @Override
    public void pause() {
        switch (mCurrentState) {
        case STATE_PLAYING:
            System.out.println("pause vedio now");
            break;
        case STATE_PAUSED:
            System.out.println(" curent state is paused, do noting.");
        case STATE_STOPPED:
            System.out.println("curent state is stopped,do noting.");
            break;
        default:
            // would it happen? who care.
            break;
        }
        mCurrentState = STATE_PAUSED;
    }

    @Override
    public void stop() {
        switch (mCurrentState) {
        case STATE_PLAYING:
        case STATE_PAUSED:
            System.out.println(" stop vedio now.");
        case STATE_STOPPED:
            System.out.println("curent state is stopped,do noting.");
            break;
        default:
            // would it happen? who care.
            break;
        }
        mCurrentState = STATE_STOPPED;
    }


}

看着还错喔。

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

public interface IPlayer {
    public static final int STATE_PLAYING = 1;
    public static final int STATE_PAUSED = 2;
    public static final int STATE_STOPPED = 3;
    public static final int STATE_AD = 4;
    
    public void palyVedio();
    public void pause();
    public void stop();
    public void showAD();
}

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

    @Override
    public void showAD() {
        switch (mCurrentState) {
        case STATE_AD:
            System.out.println("curent state is AD,do noting");
            break;
        case STATE_PLAYING:
            System.out.println("show advertisement now.");
            break;
        case STATE_PAUSED:
            System.out.println("curent state is paused , do noting");
        case STATE_STOPPED:
            System.out.println("curent state is stopped ,do noting.");
            break;
        default:
            // would it happen? who care.
            break;
        }
        mCurrentState = STATE_AD;
    }

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

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

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

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

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

public abstract class IPlayer {
    
    public abstract void request(int flag);
    
    public abstract void setState(PlayerState state);
    
    public abstract void palyVedio();

    public abstract void pause();

    public abstract void stop();

    public abstract void showAD();
}

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

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

public abstract class PlayerState {
    public final static int PLAY_OR_PAUSE=0;
    public final static int STOP=1;
    protected IPlayer mPlayer;
    public PlayerState(IPlayer player) {
        this.mPlayer=player;
    }
    public abstract void handle(int action);
    @Override
    public String toString() {
        return "current state:"+this.getClass().getSimpleName();
    }
}

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

public class PlayingState extends PlayerState {
    public PlayingState(IPlayer player) {
        super(player);
    }

    @Override
    public void handle(int action) {
        switch (action) {
        case PlayingState.PLAY_OR_PAUSE:
            mPlayer.pause();
            mPlayer.setState(new PausedState(mPlayer));
            break;
        case PlayerState.STOP:
            mPlayer.stop();
            mPlayer.setState(new StoppedState(mPlayer));
            break;
        default:
            throw new IllegalArgumentException("ERROE ACTION:"+action+",current state:"+this.getClass().getSimpleName());
        }
    }
}

public class PausedState extends PlayerState {

    public PausedState(IPlayer player) {
        super(player);
    }
    @Override
    public void handle(int action) {
        switch (action) {
        case PlayingState.PLAY_OR_PAUSE:
            mPlayer.palyVedio();
            mPlayer.setState(new PlayingState(mPlayer));
            break;
        case PlayerState.STOP:
            mPlayer.stop();
            mPlayer.setState(new StoppedState(mPlayer));
            break;
        default:
            throw new IllegalArgumentException("ERROE ACTION:"+action+",current state:"+this.getClass().getSimpleName());
        }
    }
}

public class StoppedState extends PlayerState {

    public StoppedState(IPlayer player) {
        super(player);
    }

    @Override
    public void handle(int action) {
        switch (action) {
        case PlayingState.PLAY_OR_PAUSE:
            mPlayer.palyVedio();
            mPlayer.setState(new PlayingState(mPlayer));
            break;
        default:
            throw new IllegalArgumentException("ERROE ACTION:"+action+",current state:"+this.getClass().getSimpleName());
        }
    }
}

最后就是IPlayer的实现类VedioPlayer

public class VedioPlayer extends IPlayer {
    private PlayerState mState=new StoppedState(this);

    @Override
    public void palyVedio() {
        System.out.println("play vedio!");
    }

    @Override
    public void pause() {
        System.out.println("pause vedio!");
    }

    @Override
    public void stop() {
        System.out.println("stop vedio!");
    }

    // @Override
    // public void showAD() {
    // System.out.println("show AD!");
    // }

    @Override
    public void setState(PlayerState state) {
        mState = state;
    }

    @Override
    public void request(int action) {
        System.out.println("before action:" + mState.toString());
        mState.handle(action);
        System.out.println("after action:" + mState.toString());
    }

}

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

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        IPlayer player=new VedioPlayer();
        int i=-1;
        while((i=sc.nextInt())!=-1){
            player.request(i);
        }
    }

}

依次如下输入：

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

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

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

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

@Override
    public void showAD() {
        System.out.println("show AD!");
    }

　　现在增加一个ADState

public class ShowADState extends PlayerState {
    public ShowADState(IPlayer player) {
        super(player);
    }
    @Override
    public void handle(int action) {
        switch (action) {
        case PlayingState.PLAY_OR_PAUSE:
            mPlayer.palyVedio();
            mPlayer.setState(new PlayingState(mPlayer));
            break;
        default:
            throw new IllegalArgumentException("ERROE ACTION:"+action+","+this.toString());
        }
    }

}

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

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

public class PlayingState extends PlayerState {
    public PlayingState(IPlayer player) {
        super(player);
    }

    @Override
    public void handle(int action) {
        switch (action) {
        case PlayingState.PLAY_OR_PAUSE:
            mPlayer.pause();
            mPlayer.setState(new PausedState(mPlayer));
            break;
        case PlayerState.STOP:
            mPlayer.stop();
            mPlayer.setState(new StoppedState(mPlayer));
            break;
        case PlayingState.SHOW_AD:
            mPlayer.showAD();
            mPlayer.setState(new ShowADState(mPlayer));
            break;
        default:
            throw new IllegalArgumentException("ERROE ACTION:"+action+",current state:"+this.getClass().getSimpleName());
        }
    }
}

增加了17到20行的代码。

再来验证程序：

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

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

总结：

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

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

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