状态模式

2019-12-04  本文已影响0人  缓慢移动的蜗牛

状态模式的定义

定义:当一个对象内在状态改变时允许其改变行为,这个对象看起来就像改变了其类。
状态模式的核心是封装,状态的变更引起了行为的变更,从外部看了起来好像这个对象对应的类发生了改变一样,状态模式的通用类图如下:

角色的定义

状态模式相对来说比较复杂,它提供了一种对物质运动的另一个观察视角,通过状态变更促使行为的变化,就类似于水的状态变更一样,一碗水的初始状态是液态,通过加热转变为气态,状态的改变同时也引起体积的扩大,然后就产生了一个新的行为:鸣笛或顶起壶盖。

通用源码如下:
抽象环境角色

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() {
             //本状态下必须处理的逻辑
     }
     @Override
     public void handle2() {
             //设置当前状态为stat2
             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() {
             //本状态下必须处理的逻辑
     }
}

具体环境角色有两个职责:处理本状态必须完成的任务,决定是否可以过渡到其他状态。
具体环境角色

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;
             //切换状态
             this.CurrentState.setContext(this);
     }
     //行为委托
     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(new ConcreteState1());
             //行为执行
             context.handle1();
             context.handle2();
     }
}

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

状态模式的应用

状态模式的优点

状态模式的缺点

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

状态模式的使用场景

状态模式的注意事项

状态模式适用于当某个对象在它的状态发生改变时,它的行为也随着发生比较大的变化,也就是说在行为状态约束下可以使用状态模式,而且使用时对象的状态最好不要超过5个。

示例

模拟电梯的运行情况,电梯具有的一些动作:开门、关门、运行、停止。
电梯的状态与动作之间的关系如下如:

开门(open) 关门(close) 运行(run) 停止(stop)
敞门状态 X X X
闭门状态 X
运行状态 X X X
停止状态 X X

以状态为导向,就是根据不同状态可执行不同的动作,类图如下:


在类图中,定义了一个LiftState抽象类,声明了一个受保护的类型Context变量,这个是串联各个状态的封装类。封装的目的很明显,就是对电梯内部状态的变化不被调用类知晓,也就是迪米特法则了,并且还定义了4个具体的实现类,承担的是状态的生产及状态间的转换过度。
抽象电梯状态

public abstract class LiftState{
     //定义一个环境角色,也就是封装状态的变化引起的功能变化
     protected Context context;
     public void setContext(Context context){
             this.context = context;
     }
     //首先电梯门开启动作
     public abstract void open();
     //电梯门有开启,那当然也就有关闭了
     public abstract void close();
     //电梯要能上能下,运行起来
     public abstract void run();
     //电梯还要能停下来
     public abstract void stop();
}

敞门状态

public class OpeningState extends LiftState{
    @Override
    public void open() {
        System.out.println("电梯门开启");
    }

    @Override
    public void close() {
        super.context.setLiftState(Context.CLOSING_STATE);
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        //门开着,电梯不能运行
        //do nothing
    }

    @Override
    public void stop() {
        //门开着,电梯就处于停止状态
        //do nothing
    }
}

Openning状态是由open0方法生的,因此,在这个方法中有一个具体的业务逻辑,我们是用print来代替了。在Openning状态下,电梯能过渡到其他什么状态呢?按照现在的定义的是只能过渡到Closing状态,因此我们在Close(中定义了状态变更,同时把Close这个动作也委托了给CloseState类下的Close方法执行,这个可能不好理解,我们
再看看Context类可能好理解点
上下文类

public class Context {
    //定义出所有的电梯状态
    public final static OpeningState OPENING_STATE = new OpeningState();
    public final static ClosingState CLOSING_STATE = new ClosingState();
    public final static RunningState RUNNING_STATE = new RunningState();
    public final static StoppingState STOPPING_STATE = new StoppingState();


    //定义一个当前电梯状态
    private LiftState liftState;
    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        this.liftState.setContext(this);
    }
    public LiftState getLiftState() {
        return liftState;
    }

    public void open() {
        this.liftState.open();
    }

    public void close() {
        this.liftState.close();
    }

    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

结合以上3个类,我们可以这样理解:Context是一个环境角色,它的作用是串联各个状态的过渡,在LiftSate抽象类中我们定义并把这个环境角色聚合进来,并传递到子类,也就是4个具体的实现类中自己根据环境来决定如何进行状态的过渡。

关闭状态

public class ClosingState extends LiftState {
    @Override
    public void open() {
        //电梯门关了,可以再打开
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        System.out.println("电梯门关闭");
    }

    @Override
    public void run() {
        //电梯门是关闭着的,可以运行
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();

    }

    @Override
    public void stop() {
        //电梯门关着的,可以停止
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }
}

运行状态

public class RunningState extends LiftState{
    @Override
    public void open() {
        //电梯运行时,不能打开
        //do nothing
    }

    @Override
    public void close() {
        //电梯运行时,门就是关着的
        //do nothing
    }

    @Override
    public void run() {
        System.out.println("电梯上下运行");
    }

    @Override
    public void stop() {
        //电梯运行这,可以停止
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }
}

停止状态

public class StoppingState extends LiftState{
    @Override
    public void open() {
        //停止状态,可以开门
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        //停止状态,门就是关闭的
        //do nothing
    }

    @Override
    public void run() {
        //停止状态可以运行
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    @Override
    public void stop() {
        System.out.println("电梯停止了");
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setLiftState(Context.CLOSING_STATE);

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}
上一篇 下一篇

猜你喜欢

热点阅读