设计模式-18-状态模式

一、状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。

在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

二、介绍

意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。

主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

何时使用：代码中包含大量与对象状态有关的条件语句。

如何解决：将各种具体的状态类抽象出来。

关键代码：通常命令模式的接口中只有一个方法。而状态模式的接口中有一个或者多个方法。而且，状态模式的实现类的方法，一般返回值，或者是改变实例变量的值。也就是说，状态模式一般和对象的状态有关。实现类的方法有不同的功能，覆盖接口中的方法。状态模式和命令模式一样，也可以用于消除 if...else 等条件选择语句。

应用实例： 1、打篮球的时候运动员可以有正常状态、不正常状态和超常状态。 2、曾侯乙编钟中，'钟是抽象接口','钟A'等是具体状态，'曾侯乙编钟'是具体环境（Context）。

优点： 1、封装了转换规则。 2、枚举可能的状态，在枚举状态之前需要确定状态种类。 3、将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。 4、允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。 5、可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

缺点： 1、状态模式的使用必然会增加系统类和对象的个数。 2、状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。 3、状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码。

使用场景： 1、行为随状态改变而改变的场景。 2、条件、分支语句的代替者。

注意事项：在行为受状态约束的时候使用状态模式，而且状态不超过 5 个。

三、结构

状态模式包含以下主要角色：

        1、环境角色：也成为上下文。它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理

        2、抽象状态角色：定义一个接口，用以封装环境对象中的特定状态对应的行为

        3、具体状态角色：实现抽象状态所对应的行为

四、代码实现

创建一个抽象状态角色类

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: LiftState
 * @Description: 抽象状态类
 * @Date: 2022/4/4 14:09
 **/
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();

}

生成环境角色

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: Context
 * @Description: 环境角色类
 * @Date: 2022/4/4 14:09
 **/
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 LiftState getLiftState(){
        return liftState;
    }

    //  设置当前状态对象
    public void setLiftState(LiftState liftState){
        this.liftState=liftState;
        //  设置当前状态对象中的Context对象
        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();
    }

}

生成具体角色类

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: OpeningState
 * @Description: 电梯开启状态类
 * @Date: 2022/4/4 14:11
 **/
public class OpeningState extends LiftState {

    //  当前状态要执行的方法
    @Override
    public void open() {
        System.out.println("电梯开启");
    }

    @Override
    public void close() {
        //  修改状态
        super.context.setLiftState(Context.CLOSING_STATE);
        //  调用当前状态中context中的close方法
    }

    @Override
    public void run() {
        //  什么都不做
    }

    @Override
    public void stop() {
        //  什么都不做
    }
}

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: ClosingState
 * @Description: 电梯关闭状态类
 * @Date: 2022/4/4 14:11
 **/
public class ClosingState extends LiftState {


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

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

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

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

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: OpeningState
 * @Description: 电梯运行状态类
 * @Date: 2022/4/4 14:11
 **/
public class RunningState extends LiftState {


    @Override
    public void open() {
        //  运行时电梯不会关
    }

    @Override
    public void close() {
        //  虽然门关闭了 但这个动作不归我执行
    }

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

    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }
}

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: OpeningState
 * @Description: 电梯停止状态类
 * @Date: 2022/4/4 14:11
 **/
public class StoppingState extends LiftState {


    @Override
    public void open() {
        //  状态修改
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        //  状态修改
        super.context.setLiftState(Context.CLOSING_STATE);
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        //  停止了再跑起来
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

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

客户

package SP_02_State;

/**
 * @Author: {LZG}
 * @ClassName: Client
 * @Description: TODO
 * @Date: 2022/4/4 15:34
 **/
public class Client {
    public static void main(String[] args) {
        //  创建环境角色对象
        Context context = new Context();
        //  设置当前电梯状态
        context.setLiftState(new RunningState());

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


    }
}

测试结果

 类图

 五、优缺点

优点：

        1、将所有与某个状态有关的行为放到一个类中，并且可以方便的增加新的状态，只需要改变对象即可改变对象的行为。

        2、允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块

缺点：

        1、状态模式的使用必然会增加系统类和对象的个数

        2、状态模式的结构与实现都较为复杂，如果使用不当将会导致程序结构和代码的混乱

        3、状态模式对开闭原则的支持并不太好