状态模式——每天学习一种设计模式

玉米迪迪

已于 2022-05-04 10:58:45 修改

阅读量411

点赞数 2

分类专栏：设计模式文章标签：状态模式设计模式

于 2022-03-16 22:14:57 首次发布

本文链接：https://blog.csdn.net/weixin_46041230/article/details/123537926

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

设计模式之状态模式

1 状态模式(State Pattern)

1 状态模式(State Pattern)

1.1 什么是状态模式？

在很多情况下，一个对象的行为取决于一个或多个动态变化的属性，这样的属性叫状态，这样的对象叫做有状态的对象。这样的对象状态都是从事先定义好的一系列值中取出来的。当一个对象与外部事件产生交互，内部状态就会发生改变，从而系统行为也随之变化。

状态模式(State Pattern):==允许一个对象在其内部状态改变时改变他的行为，对象看起来似乎修改了它的类。==别名：状态对象（Object for States），是一种对象行为型模式。

1.2 结构与角色

状态模式包括三种角色。
①Context:上下文环境。定义客户应用程序有兴趣的接口，保留一个具体状态类的对象，该对象给出此情景对象的现有状态。

②State:抽象状态。定义一个接口或者是一个抽象状态类，以封装与Context的一个特定状态所对应的行为。

③ConcreteState:具体状态类。实现State接口，对Context的每一个状态进行具体的状态行为描述。
在这里插入图片描述

由图1我们可以看出来，状态模式的关键是引入了一个抽象类来专门表示对象的状态，即State。对象的每一种具体状态都继承该抽象状态类或者实现这个接口。，并在不同具体状态中实现不同状态的行为，包括各种状态之间的转换。

状态类的产生是由于环境类存在多个状态，同时还满足两个条件：状态经常需要切换，不同状态下对象的行为不同。

1.3 一个示例和一个实例——电梯运转

这个示例模拟的是事件发生使用状态模式进行状态转换的基本过程。

package DesignModel;

interface  State{       //抽象状态   这里用接口来表示
    void handle(Context context);
    //接口的方法在非抽象类子类实现时必须要补全方法
}
class Context{  //情景类，持有一个State对象，并把所有的行为委派给此对象
    private State state; //这是一个对象
    public void setState(State state){
        this.state = state;
    }
    public void request(){  //请求委派一个具体状态类的对象
        state.handle(this); //对象名.方法名()
    }
}

class ConcreteState1 implements State{  //具体状态类
    @Override
    public void handle(Context context) {
        System.out.println("handle in ConcreteState1");
        System.out.println("change to State1");
        context.setState(new ConcreteState2()); //切换状态
    }
}

class ConcreteState2 implements  State{ //具体状态类

    @Override
    public void handle(Context context) {
        System.out.println("handle in ConcreteState2");
        System.out.println("change to State2");
        context.setState(new ConcreteState1()); //切换状态
    }
}

public class StatePatternDemo01 {
    public static void main(String[] args) {
        //创建当前环境对象
        Context context = new Context();
        //调用setState方法设置当前环境状态   直接通过创建状态1对象给环境对象
        context.setState(new ConcreteState1());
        //将当前环境状态委派给具体的状态并进行操作
        context.request();
        //重复执行四次
        context.request();
        context.request();
        context.request();
    }
}

接下来是使用状态模式模拟电梯在通电时的一些基本状态并画出它的结构类图。

package DesignModel;

class LiftContext{
    //定义所有的电梯状态
    public final static OpeningState openningState = new OpeningState();
    public final static CloseingState closeingState = new CloseingState();
    public final static RunningState runningState = new RunningState();
    public final static StoppingState stoppingState = new StoppingState();

    //定义电梯当前的状态
    private LiftState liftState;

    public LiftState getLiftState(){
        return liftState;
    }

    public void setLiftState(LiftState liftState){
        this.liftState = liftState;
        //把当前的环境通知到各个实现类中
        this.liftState.setContext(this);
    }

    public void open(){
        this.liftState.open();
    }
    public void close(){
        this.liftState.close();
    }
    public void run(){
        this.liftState.run();
    }
    public void stop(){
        this.liftState.stop();
    }
}

abstract class LiftState{
    //定义一个环境角色，也就是封装状态的变换引起的功能变化
    protected  LiftContext context;
    public void setContext(LiftContext context){
        this.context = context;
    }
    //电梯门开启动作
    public  abstract void open();
    //电梯门关闭动作
    public abstract void close();
    //电梯启动动作
    public abstract void run();
    //电梯停止动作
    public abstract void stop();
}
//电梯门打开状态实现类
class OpeningState extends LiftState{

    @Override
    public void open() {
        System.out.println("电梯门打开了......");
    }
    //电梯门处于打开状态时，能够进行关门动作
    @Override
    public void close() {
        //状态修改
        context.setLiftState(LiftContext.closeingState);
        //动作委派为CloseState来执行
        context.getLiftState().close();
    }

    @Override
    public void run() {
        //电梯门开状态不能运行
    }

    @Override
    public void stop() {
        //开门就已经停止了
    }
}

class CloseingState extends LiftState{

    @Override
    public void open() {
        context.setLiftState(LiftContext.openningState);
        context.getLiftState().open();
    }

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

    @Override
    public void run() {
        context.setLiftState(LiftContext.runningState);
        context.getLiftState().run();
    }

    @Override
    public void stop() {
        context.setLiftState(LiftContext.stoppingState);
        context.getLiftState().stop();
    }
}

class RunningState extends LiftState{

    @Override
    public void open() {
        //电梯运行状态不能开门
    }

    @Override
    public void close() {
        //电梯运行的时候，门当然是关着的
    }

    @Override
    public void run() {
        System.out.println("电梯正在运行中......");
    }

    @Override
    public void stop() {
        context.setLiftState(LiftContext.stoppingState);//环境设置为停止状态
        context.getLiftState().stop();
    }
}

class StoppingState extends LiftState{
    //停止状态可以开门操作
    @Override
    public void open() {
        context.setLiftState(LiftContext.openningState);
        context.getLiftState().open();
    }

    @Override
    public void close() {
        //停止状态电梯门本来就是关着的
    }

    @Override
    public void run() {
        //停止状态然后启动运行  可以
        context.setLiftState(LiftContext.runningState);
        context.getLiftState().run();
    }

    @Override
    public void stop() {
        System.out.println("电梯停止了.....");
    }
}
public class StatePatternDemo02 {
    //模拟电梯动作
    public static void main(String[] args) {
        LiftContext context = new LiftContext();
        context.setLiftState(new CloseingState());

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

1.4 状态模式的优点

避免了程序的复杂性。在简单的程序中，有多个状态的选择时，通常我们会使用swith…case语句或if…else语句，使用单例模式，对每个状态进行封装，使程序变得不会过分冗余。
很好的使用体现了开闭原则和单一职责原则，每个状态都是一个子类，需要增加状态就增加子类；修改状态，只需修改一个子类。
封装性好。将状态转换放到类的内部实现，外部的调用不需清楚内部如何实现状态和行为的变换，即封装了转换规则。这也是单例模式的基本要求。