策略模式的双胞胎：状态模式

Simple Demo

假设我有一部iPhoneX，又非常喜欢玩游戏，那么我这部破手机主要存在两种状态：待机和游戏中。

此时手机的状态图非常简单：

将这个状态图转换为代码：

每一个状态用不同的整数代表，将每一个动作整合成方法，每一个动作都可能造成状态的转换。

public class MyiPhoneX {
    public final static int    STANDBY    = 0;        // 待机状态
    public final static int    PLAYING    = 1;        // 游戏进行中状态
    private int                state    = STANDBY;    // 持有当前状态的实例变量

    public MyiPhoneX() {
    }

    public void startGame() { // 打开游戏
        if (state == STANDBY) {
            System.out.println("Game is loading...");
            state = PLAYING;
        } else if (state == PLAYING) {
            System.out.println("Game is already in progress!");// 已存在该游戏进程
        }
    }

    public void exitGame() { // 结束游戏
        if (state == STANDBY) {
            System.out.println("There is no game process!");// 不存在游戏进程，这是此状态的一个不恰当动作
        } else if (state == PLAYING) {
            System.out.println("Game is exiting...");
            state = STANDBY;
        }
    }
}

测试代码：

public class MyiPhoneXTest {
    public static void main(String[] args) {
        MyiPhoneX iPhoneX = new MyiPhoneX();
        iPhoneX.startGame();
        iPhoneX.exitGame();
        iPhoneX.exitGame();
        iPhoneX.startGame();
        iPhoneX.exitGame();
    }
}

Game is loading...
Game is exiting...
There is no game process!
Game is loading...
Game is exiting...

更改需求

但存在一种特殊情况：遇上了某款“渣渣游戏”，其在响应网络方面的功能没有很完善，我的iPhoneX在加载这款游戏的过程中某个瞬间网络状况不太好，进入了“游戏无限加载”状态，最后只能选择退出游戏后再重新尝试打开游戏。

下面是加入“无限加载状态”的手机状态图：

如果在第原版本的代码进行维护，需要作如下修改：

可这样的代码不易于扩展，我的iPhoneX每新增一个状态，需要MyiPhoneX类做出的改变地方可能会更多，这样的设计不符合“对修改关闭，对扩展开放”的原则、也不够面向对象。

而且这还只是一个只有两三个状态的简单例子，如果是状态及操作方法较多的程序，按照以上的设计，代码臃肿混乱，每新增一个状态，需要在每个操作方法里都新增一个 else if 判断，所有的代码维护都堆积在一个类中。

新的设计

为了更容易的维护和修改程序，我们需要对原代码重新设计：

我们将每个状态的行为都放在各自的类中（将会改变的那部分封装起来），那么每个状态类只要实现它自己的动作就可以了，对iPhoneX执行的动作只需要委托给当前状态的状态对象来具体执行就好了。我们可以这么做：

① 先定义一个State接口，iPhoneX可以执行的每一个动作都有对应的方法在这个接口内。（面向接口编程）

② iPhoneX的每个状态都有一个对应的实现了State接口的具体状态类。

③ 对iPhoneX执行动作委托给具体状态类来执行。

状态接口和其具体实现类的类图如下：

实际代码：

public interface State {
    void startGame();

    void exitGame();
}

具体状态实现类主要做的是实现适合所在的这个状态的具体动作。

public class Standby implements State {  //“待机”状态
    private MyiPhoneX    iPhoneX;

    public Standby(MyiPhoneX iPhoneX) {
        this.iPhoneX = iPhoneX;
    }

    @Override
    public void startGame() {
        System.out.println("Game is loading..."); // 游戏正在加载
        iPhoneX.setState(iPhoneX.getPlaying()); // iPhone修改为“游戏中状态”
    }

    @Override
    public void exitGame() {
        System.out.println("There is no game process!");// 不存在该游戏进程，这是此状态的一个不恰当动作
    }
}

public class Playing implements State {  //“游戏中”状态
    private MyiPhoneX iPhoneX;

    public Playing(MyiPhoneX iPhoneX) {
        this.iPhoneX = iPhoneX;
    }

    @Override
    public void startGame() {
        System.out.println("Game is already in progress!");// 已存在该游戏进程
    }

    @Override
    public void exitGame() {
        System.out.println("Game is exiting..."); // 退出游戏中
        iPhoneX.setState(iPhoneX.getStandby()); // iPhone修改为“待机状态”
    }
}

我的iPhoneX实体类：

public class MyiPhoneX {
    private State    standby;
    private State    playing;
    private State    state    ;    // 持有当前状态的实例变量

    public MyiPhoneX() {
        standby = new Standby(this);
        playing = new Playing(this);
        state = standby;
    }

    public void startGame() { // 打开游戏
        state.startGame();
    }

    public void exitGame() { // 结束游戏
        state.exitGame();
    }

    public void setState(State state) { // 用于修改手机当前状态
        this.state = state;
    }

    public State getStandby() {
        return standby;
    }

    public State getPlaying() {
        return playing;
    }
}

实现需求

将新的“游戏无限加载”状态加上，代码修改如下：

增加遇到渣渣游戏的“游戏无限加载”状态类：

public class RubbishGame implements State { //“游戏无限加载”状态
    private MyiPhoneX iPhoneX;

    public RubbishGame(MyiPhoneX iPhoneX) {
        this.iPhoneX = iPhoneX;
    }

    @Override
    public void startGame() {
        System.out.println("Game is already in progress!");// 已存在该游戏进程
    }

    @Override
    public void exitGame() {
        System.out.println("Game is exiting..."); // 退出游戏中
        iPhoneX.setState(iPhoneX.getStandby()); // iPhone修改为“待机状态”
    }
}

在MyiPhoneX类中添加引用“游戏无限加载”状态的实例变量：

public class MyiPhoneX {
    private State    standby;
    private State    playing;
    private State    rubbishGame; //添加遇到渣渣游戏的“游戏无限加载”状态
    private State    state;        // 持有当前状态的实例变量

    public MyiPhoneX() {
        standby = new Standby(this);
        playing = new Playing(this);
        rubbishGame = new RubbishGame(this); //初始化“游戏无限加载”状态
        state = standby;
    }

    public void startGame() { // 打开游戏
        state.startGame();
    }

    public void exitGame() { // 结束游戏
        state.exitGame();
    }

    public void setState(State state) { // 用于修改手机当前状态
        this.state = state;
    }

    public State getStandby() {
        return standby;
    }

    public State getPlaying() {
        return playing;
    }

    public State getRubbishGame() { //提供获取“游戏无限加载”状态的方法
        return rubbishGame;
    }
}

修改“待机”状态类，我们用随机数代表遇到“渣渣游戏”的机会，增加从“待机”到“游戏无限加载”状态的转换的代码：

public class Standby implements State {
    private MyiPhoneX    iPhoneX;
    private Random        randomRubbish    = new Random(); //用于产生随机数

    public Standby(MyiPhoneX iPhoneX) {
        this.iPhoneX = iPhoneX;
    }

    @Override
    public void startGame() {
        int rubbish = randomRubbish.nextInt(10);
        if (rubbish <= 1) {
            System.out.println("Rubbish Game!"); // 游戏正在加载
            iPhoneX.setState(iPhoneX.getRubbishGame()); // iPhone修改为“游戏中状态”
        } else {
            System.out.println("Game is loading..."); // 游戏正在加载
            iPhoneX.setState(iPhoneX.getPlaying()); // iPhone修改为“游戏中状态”
        }

    }

    @Override
    public void exitGame() {
        System.out.println("There is no game process!");// 不存在该游戏进程，这是此状态的一个不恰当动作
    }

}

测试代码：

public class MyiPhoneXTest {
    public static void main(String[] args) {
        MyiPhoneX iPhoneX = new MyiPhoneX();
        iPhoneX.startGame();
        iPhoneX.exitGame();
        iPhoneX.startGame();
        iPhoneX.exitGame();
        iPhoneX.startGame();
        iPhoneX.exitGame();
        iPhoneX.startGame();
        iPhoneX.exitGame();
    }
}

Rubbish Game!
Game is exiting...
Game is loading...
Game is exiting...
Rubbish Game!
Game is exiting...
Game is loading...
Game is exiting...

这样就为我的iPhoneX增加了一个新的状态，并实现了这个新的状态。要做的只是新增这个状态类及增加能够转换到这个状态的代码。

相对最早的代码版本，删除了容易产生问题的if语句，日后更好维护，让大多数状态类“对修改关闭”，让MyiPhoneX“对扩展开放”，而且这样的代码结构，对应起相关的状态图也更容易阅读和理解。

这样设计的好处在这个比较简单的例子里看起来可能不是很明显；假如是在多个状态的程序，我们新增一个状态，只需新增这个状态的实体类、在主体类中加入这个新状态类的实例引用、在能够转换到这个状态的其他状态类加入转换的逻辑代码就可以了。

状态模式：

以上的新设计采用了状态模式，状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

这个模式将状态封装成独立的类，并将动作委托到代表当前状态的对象，我的iPhoneX在“待机”和“游戏中”两种不同状态时，如果执行“开始游戏”的动作，就会得到不同的具体行为（提示已开启游戏和启动游戏）。

我们使用组合通过简单引用不同的状态对象来造成类改变的假象（执行一个动作时，当前的状态对象的具体动作里可能会转换内部的状态，而客户的视角是主体对象自己发生了改变，没有意识到是状态对象起的作用）。

状态模式的类图：

我们可以发现，它和策略模式的类图是一样的。

两个模式的差别在于它们的“意图”不同。

①对状态模式而言

将具体行为封装在状态类中，Context的行为委托给当前具体状态对象来执行，执行具体行为后可能会改变当前状态，这样Context执行的具体行为也在改变（每个状态类对每种行为都有各自的具体实现）。而使用Context的客户对于状态对象却是陌生的、甚至是未知的。这个方案可以去掉原本存在Context内的许多的条件判断，通过Context对象内简单的改变状态对象来改变行为。

②对策略模式而言

客户对于策略对象是很熟悉的，通常由客户主动选择Context需要组合的策略对象，而且虽然策略模式可以在运行时改变策略，但对于某个Context对象来说，通常只有一个最适当的策略对象。一般用来作为除了继承之外的一种弹性替代方案，通过组合不同对象来改变行为。

参考书籍：《Head First 设计模式》

posted @ 2018-01-19 22:29 红红豆泥阅读(592) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

红红豆泥