「补课」进行时:设计模式(19)——状态模式

「补课」进行时:设计模式(19)——状态模式

1. 前文汇总

「补课」进行时:设计模式系列

2. LOL 中的状态

感觉我天天在用 LOL 举例子,没办法,都已经 S11 了,而我依然在玩这个游戏。

LOL 中的英雄有很多状态,有正常状态,有吃了伟哥一样的加速状态,有被对方套了虚弱的虚弱状态,还有被对方控制的眩晕状态。

下面来看下,在 LOL 中,初始的英雄状态:

public class Hero {
    //正常状态
    public static final int COMMON = 1;
    //加速状态
    public static final int SPEED_UP = 2;
    //减速状态
    public static final int SPEED_DOWN = 3;
    //眩晕状态
    public static final int SWIM = 4;
    //默认是正常状态
    private int state = COMMON;
    //跑动线程
    private Thread runThread;
    //设置状态
    public void setState(int state) {
        this.state = state;
    }
    //停止跑动
    public void stopRun() {
        if (isRunning()) runThread.interrupt();
        System.out.println("--------------停止跑动---------------");
    }
    //开始跑动
    public void startRun() {
        if (isRunning()) {
            return;
        }
        final Hero hero = this;
        runThread = new Thread(new Runnable() {
            public void run() {
                while (!runThread.isInterrupted()) {
                    try {
                        hero.run();
                    } catch (InterruptedException e) {
                        break;
                    }
                }
            }
        });
        System.out.println("--------------开始跑动---------------");
        runThread.start();
    }
    private boolean isRunning(){
        return runThread != null && !runThread.isInterrupted();
    }
    //英雄类开始奔跑
    private void run() throws InterruptedException{
        if (state == SPEED_UP) {
            System.out.println("--------------加速跑动---------------");
            Thread.sleep(2000);//假设加速持续2秒
            state = COMMON;
            System.out.println("------加速状态结束,变为正常状态------");
        }else if (state == SPEED_DOWN) {
            System.out.println("--------------减速跑动---------------");
            Thread.sleep(2000);//假设减速持续2秒
            state = COMMON;
            System.out.println("------减速状态结束,变为正常状态------");
        }else if (state == SWIM) {
            System.out.println("--------------不能跑动---------------");
            Thread.sleep(1000);//假设眩晕持续2秒
            state = COMMON;
            System.out.println("------眩晕状态结束,变为正常状态------");
        }else {
            //正常跑动则不打印内容
        }
    }
}

场景类:

public class Client {
    public static void main(String[] args) throws InterruptedException {
        Hero hero = new Hero();
        hero.startRun();
        hero.setState(Hero.SPEED_UP);
        Thread.sleep(2000);
        hero.setState(Hero.SPEED_DOWN);
        Thread.sleep(2000);
        hero.setState(Hero.SWIM);
        Thread.sleep(2000);
        hero.stopRun();
    }
}

可以看到,我们的英雄在跑动过程中随着状态的改变,我们的英雄会以不同的状态进行跑动。

但是问题也随之而来,我们的英雄类当中有明显的 if else 结构,这并不是我们希望看到的,接下来,我们看下状态模式。

3. 状态模式

3.1 定义

状态模式的定义如下:

Allow an object to alter its behavior when its internal state changes.The object will appear to change its class.(当一个对象内在状态改变时允许其改变行为, 这个对象看起来像改变了其类。)

3.2 通用类图

「补课」进行时:设计模式(19)——状态模式

  • State 抽象状态角色:接口或抽象类, 负责对象状态定义, 并且封装环境角色以实现状态切换。
  • ConcreteState 具体状态角色:每一个具体状态必须完成两个职责: 本状态的行为管理以及趋向状态处理, 通俗地说,就是本状态下要做的事情, 以及本状态如何过渡到其他状态。
  • Context 环境角色:定义客户端需要的接口, 并且负责具体状态的切换。

状态模式从类图上看比较简单,实际上还是比较复杂的,它提供了一种对物质运动的另一个观察视角, 通过状态变更促使行为的变化。

类似水的状态变更一样, 一碗水的初始状态是液态, 通过加热转变为、气态, 状态的改变同时也引起体积的扩大, 然后就产生了一个新的行为: 鸣笛或顶起壶盖,瓦特就是这么发明蒸汽机的。

3.3 通用代码:

抽象环境角色:

public abstract class State {
    // 定义一个环境角色,提供子类访问
    protected Context context;
    // 设置环境资源
    public void setContext(Context context) {
        this.context = context;
    }
    // 行为1
    abstract void handle1();
    // 行为2
    abstract void handle2();
}

具体环境角色:

public class ConcreteState1 extends State {
    @Override
    void handle1() {
        //本状态下必须处理的逻辑
    }

    @Override
    void handle2() {
        //设置当前状态为stat2
        super.context.setCurrentState(Context.STATE2);
        //过渡到state2状态, 由Context实现
        super.context.handle2();
    }
}

public class ConcreteState2 extends State {
    @Override
    void handle1() {
        //设置当前状态为stat2
        super.context.setCurrentState(Context.STATE1);
        //过渡到state2状态, 由Context实现
        super.context.handle1();
    }

    @Override
    void handle2() {
        // 本状态下必须处理的逻辑
    }
}

具体环境角色:

public class Context {
    final static State STATE1 = new ConcreteState1();
    final static State STATE2 = new ConcreteState2();

    private State concreteState;

    public State getCurrentState() {
        return concreteState;
    }
    //设置当前状态
    public void setCurrentState(State currentState) {
        this.concreteState = currentState;
        //切换状态
        this.concreteState.setContext(this);
    }
    public void handle1(){
        this.concreteState.handle1();
    }
    public void handle2(){
        this.concreteState.handle2();
    }
}

环境角色有两个不成文的约束:

  • 把状态对象声明为静态常量, 有几个状态对象就声明几个静态常量。
  • 环境角色具有状态抽象角色定义的所有行为, 具体执行使用委托方式。
public class Client {
    public static void main(String[] args) {
        //定义环境角色
        Context context = new Context();
        //初始化状态
        context.setCurrentState(new ConcreteState1());
        //行为执行
        context.handle1();
        context.handle2();
    }
}

这里我们已经隐藏了状态的变化过程, 它的切换引起了行为的变化。 对外来说, 我们只看到行为的发生改变, 而不用知道是状态变化引起的。

3.4 优点

  • 避免了过多的 if else 语句的使用,避免了程序的复杂性,提高系统的可维护性。
  • 使用多态代替了条件判断,这样我们代码的扩展性更强,比如要增加一些状态,会非常的容易。
  • 状态是可以被共享的,状态都是由 static final 进行修饰的。

3.5 缺点

有优点的同事也会产生缺点,有时候,优点和缺点的产生其实是同一个事实:

状态模式最主要的一个缺点是:子类会太多,也就是类膨胀。因为一个事物有很多个状态也不稀奇,如果完全使用状态模式就会有太多的子类,不好管理。

4. 案例完善

前面那个 LOL 的例子,如果使用状态模式重写一下,会是这样的:

首先创建一个跑动的接口:

public interface RunState {
    void run(Hero hero);
}

接下来是4个实现类,分别实现不同状态的跑动结果:

public class CommonState implements RunState {
    @Override
    public void run(Hero hero) {
        // 正常跑动则不打印内容,否则会刷屏
    }
}

public class SpeedUpState implements RunState{
    @Override
    public void run(Hero hero) {
        System.out.println("--------------加速跑动---------------");
        try {
            Thread.sleep(2000);//假设加速持续2秒
        } catch (InterruptedException e) {}
        hero.setState(Hero.COMMON);
        System.out.println("------加速状态结束,变为正常状态------");
    }
}

public class SpeedDownState implements RunState{
    @Override
    public void run(Hero hero) {
        System.out.println("--------------减速跑动---------------");
        try {
            Thread.sleep(2000);//假设减速持续2秒
        } catch (InterruptedException e) {}
        hero.setState(Hero.COMMON);
        System.out.println("------减速状态结束,变为正常状态------");
    }
}

public class SwimState implements RunState {
    @Override
    public void run(Hero hero) {
        System.out.println("--------------不能跑动---------------");
        try {
            Thread.sleep(1000);//假设眩晕持续1秒
        } catch (InterruptedException e) {}
        hero.setState(Hero.COMMON);
        System.out.println("------眩晕状态结束,变为正常状态------");
    }
}

最后是一个 Hero(Context) 类:

public class Hero {
    public static final RunState COMMON = new CommonState();//正常状态

    public static final RunState SPEED_UP = new SpeedUpState();//加速状态

    public static final RunState SPEED_DOWN = new SpeedDownState();//减速状态

    public static final RunState SWIM = new SwimState();//眩晕状态

    private RunState state = COMMON;//默认是正常状态

    private Thread runThread;//跑动线程
    //设置状态
    public void setState(RunState state) {
        this.state = state;
    }
    //停止跑动
    public void stopRun() {
        if (isRunning()) runThread.interrupt();
        System.out.println("--------------停止跑动---------------");
    }
    //开始跑动
    public void startRun() {
        if (isRunning()) {
            return;
        }
        final Hero hero = this;
        runThread = new Thread(new Runnable() {
            public void run() {
                while (!runThread.isInterrupted()) {
                    state.run(hero);
                }
            }
        });
        System.out.println("--------------开始跑动---------------");
        runThread.start();
    }

    private boolean isRunning(){
        return runThread != null && !runThread.isInterrupted();
    }
}

可以看到,这段代码和开头那段代码虽然完成了一样的功能,但是整个代码的复杂度缺以肉眼可见的级别提高了,一般而言,我们牺牲复杂性去换取的高可维护性和扩展性是相当值得的,除非增加了复杂性以后,对于后者的提升会乎其微。

发表评论

相关文章