《设计模式》之十九：状态模式

State Pattern 状态模式的定义如下：

Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.

当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。（这什么鸟定义，看不懂，囧）

其实通俗来讲就是，对象有几个状态，在每个状态下所允许执行的操作集合是不一样的，这个是状态机的基础。状态的变更引起了行为的变更，从外部看起来就好像是这个对象对应的类发生了改变一样。

 

状态模式中的三个角色：

1，State -- 抽象状态角色

接口或者抽象类，负责对象状态的定义，并且封装环境角色以实现状态切换。

2，ConcreteState -- 具体状态角色

每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗讲就是，本状态下要做的事情，以及本状态如果过渡到其他状态。

3，Context -- 上下文环境角色

定义客户端需要的接口，并负责具体状态的切换

 

通用源码：

public abstract class State {
    // 定义一个环境角色，提供给子类访问
    protected Context context;
    // 设置环境变量
    public void setContext(Context context) {
        this.context = context;
    }

    // 行为1
    public abstract void handle1();
    // 行为2
    public abstract void handle2();
}

 

public class ConcreteState1 extends State {
    @Override
    public void handle1() {
        // 本状态下必须要处理的逻辑
        System.out.println("状态1下面我执行一些东东了。。");
    }

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

 

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

    @Override
    public void handle2() {
        // 本状态下必须要处理的逻辑
        System.out.println("状态2下面我执行一些东东了。。");
    }
}

 

public class Context {
    // 定义状态
    public final static State STATE1 = new ConcreteState1();
    public final static State STATE2 = new ConcreteState2();

    // 当前状态
    private State currentState;

    public State getCurrentState() {
        return currentState;
    }

    public void setCurrentState(State currentState) {
        this.currentState = currentState;
        // 切换状态，将Context上下文环境传递进State对象中去
        this.currentState.setContext(this);
    }

    // 行为委托（在State抽象类中定义了几个行为，这里就定义一模一样的几个委托方法）
    public void handle1() {
        this.currentState.handle1();
    }

    public void handle2() {
        this.currentState.handle2();
    }
}

 

public class Client {
    public static void main(String[] args) {
        // 定义环境角色
        Context context = new Context();
        // 初始化状态
        context.setCurrentState(Context.STATE2);
        // 行为执行
        context.handle1();
        context.handle2();
    }
}

 

状态模式的优点：

1，结构清晰

避免了过多的swith...case的状态判断，提高了系统的可维护性

2，遵循了设计原则

很好体现了开闭原则和单一职责原则，每个状态都是一个子类，你要增加状态就要增加子类，你要修改状态，你只用修改那个子类即可，其他类不变。

3，封装性非常好

状态变换放置到类的内部去实现了，外部的调用不用知道类内部如何实现状态和行为的变换。

 

状态模式的缺点：

只有一个，子类有点多丫丫，也就是类膨胀。如果状态太多了，最好在数据库中建立一个状态表，根据状态执行响应的操作。或者使用现成的框架比如Mina的状态机机制

 

状态模式使用场景：

1，行为随状态改变而改变的场景

这也是状态模式的出发点，例如权限的设计，人员的状态不同即使执行相同的行为，结果也会不同。

2，条件、分支判断语句的替代者

 

本人博客已搬家，新地址为：http://yidao620c.github.io/