状态模式介绍

一、状态模式介绍

[1.1 状态模式的定义](#1.1 状态模式的定义)

[1.2 状态模式的原理](#1.2 状态模式的原理)

[1.2.1 状态模式类图](#1.2.1 状态模式类图)

[1.2.2 模式角色说明](#1.2.2 模式角色说明)

[1.2.3 实例代码](#1.2.3 实例代码)

二、状态模式的应用

[2.1 需求说明](#2.1 需求说明)

[2.2 需求实现](#2.2 需求实现)

[2.2.1 不使用设计模式](#2.2.1 不使用设计模式)

[2.2.2 使用状态模式](#2.2.2 使用状态模式)

[2.2.2.1 交通灯类](#2.2.2.1 交通灯类)

[2.2.2.2 交通灯状态接口](#2.2.2.2 交通灯状态接口)

[2.2.2.3 红灯状态类](#2.2.2.3 红灯状态类)

[2.2.2.4 黄灯状态类](#2.2.2.4 黄灯状态类)

[2.2.2.5 绿灯状态类](#2.2.2.5 绿灯状态类)

[2.2.2.6 测试类](#2.2.2.6 测试类)

三、状态模式总结

[3.1 状态模式的优点](#3.1 状态模式的优点)

[3.2 状态模式的缺点](#3.2 状态模式的缺点)

[3.3 状态模式常见的使用场景](#3.3 状态模式常见的使用场景)

一、状态模式介绍

1.1 状态模式的定义

**状态模式(state pattern)**的定义：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

状态模式就是用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中(用类来表示状态) ，使得对象状态可以灵活变化。

自然界很多事物都有多种状态，而且不同状态下会具有不同的行为，这些状态在特定条件下还会发生相互转换，比如水。

在软件系统中，有些对象也像水一样具有多种状态，这些状态在某些情况下能够相互转换，而且对象在不同状态下也将具有不同的行为。

1.2 状态模式的原理

1.2.1 状态模式类图

1.2.2 模式角色说明

从这个 UML 图中，我们能看出状态模式包含的关键角色有三个。

上下文信息类（Context）：实际上就是存储当前状态的类，对外提供更新状态的操作。在该类中维护着一个抽象状态接口State实例，这个实例定义当前状态。
抽象状态类（State）：可以是一个接口或抽象类，用于定义声明状态更新的操作方法有哪些，具体实现由子类完成。
具体状态类（StateA 等）：实现抽象状态类定义的方法，根据具体的场景来指定对应状态改变后的代码实现逻辑。

1.2.3 实例代码

java 复制代码

package main.java.cn.test.state.V1;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:05:06
 * @description 上下文类
 */
public class Context {
    private State currentState; //维持一个对状态对象的引用

    public Context() {
        this.currentState = null;
    }

    public State getCurrentState() {
        return currentState;
    }

    public void setCurrentState(State currentState) {
        this.currentState = currentState;
    }

    @Override
    public String toString() {
        return "Context{" + "currentState=" + currentState + '}';
    }
}

java 复制代码

package main.java.cn.test.state.V1;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:04:30
 * @description 抽象状态接口
 */
public interface State {
    //声明抽象方法,不同具体状态类可以有不同实现
    void handle(Context context);
}

java 复制代码

package main.java.cn.test.state.V1;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:05:49
 * @description 实现类A
 */
public class ConcreteStateA implements State {
    @Override
    public void handle(Context context) {
        System.out.println("进入状态模式A......");
        context.setCurrentState(this);
    }

    @Override
    public String toString() {
        return "当前状态: ConcreteStateA";
    }
}

java 复制代码

package main.java.cn.test.state.V1;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:06:28
 * @description 实现类B
 */
public class ConcreteStateB implements State {
    @Override
    public void handle(Context context) {
        System.out.println("进入状态模式B......");
        context.setCurrentState(this);

    }

    @Override
    public String toString() {
        return "当前状态: ConcreteStateB";
    }

}

java 复制代码

package main.java.cn.test.state.V1;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:07:23
 * @description 测试类
 */
public class Test {
    public static void main(String[] args) {
        Context context = new Context();
        State state1 = new ConcreteStateA();
        state1.handle(context);
        System.out.println(context.getCurrentState().toString());
        System.out.println("========================");
        State state2 = new ConcreteStateB();
        state2.handle(context);
        System.out.println(context.getCurrentState().toString());
    }
}

二、状态模式的应用

2.1 需求说明

模拟交通信号灯的状态转换。交通信号灯一般包括了红、黄、绿3种颜色状态，不同状态之间的切换逻辑为：红灯只能切换为黄灯，黄灯可以切换为绿灯或红灯，绿灯只能切换为黄灯。

2.2 需求实现

2.2.1 不使用设计模式

java 复制代码

package main.java.cn.test.state.V2;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:11:17
 * @description 交通灯类
 * 红灯(禁行) ,黄灯(警示),绿灯(通行) 三种状态。
 */
public class TrafficLight {
    //初始状态红灯
    private String state = "红";

    //切换为绿灯(通行)状态
    public void switchToGreen() {
        if ("绿".equals(state)) {//当前是绿灯
            System.out.println("当前为绿灯状态,无需切换!");
        } else if ("红".equals(state)) {
            System.out.println("红灯不能切换为绿灯!");
        } else if ("黄".equals(state)) {
            state = "绿";
            System.out.println("绿灯亮起...时长: 60秒");
        }
    }

    //切换为黄灯(警示)状态
    public void switchToYellow() {
        if ("黄".equals(state)) {//当前是黄灯
            System.out.println("当前为黄灯状态,无需切换!");
        } else if ("红".equals(state) || "绿".equals(state)) {
            state = "黄";
            System.out.println("黄灯亮起...时长:10秒");
        }
    }

    //切换为黄灯(警示)状态
    public void switchToRed() {
        if ("红".equals(state)) {//当前是绿灯
            System.out.println("当前为红灯状态,无需切换!");
        } else if ("绿".equals(state)) {
            System.out.println("绿灯不能切换为红灯!");
        } else if ("黄".equals(state)) {
            state = "红";
            System.out.println("红灯亮起...时长: 90秒");
        }
    }
}

java 复制代码

package main.java.cn.test.state.V2;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:12:28
 * @description 测试类
 */
public class Test {
    public static void main(String[] args) {
        TrafficLight trafficLight = new TrafficLight();
        // 黄灯
        trafficLight.switchToYellow();
        // 绿灯
        trafficLight.switchToGreen();
        // 红灯
        trafficLight.switchToRed();
    }
}

问题: 状态切换的操作全部在一个类中，如果有很多的交通灯进行联动，这个程序的逻辑就会变得非常复杂，难以维护。

2.2.2 使用状态模式

2.2.2.1 交通灯类

java 复制代码

package main.java.cn.test.state.V3;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:15:57
 * @description 交通灯类
 * 红灯(禁行) ,黄灯(警示),绿灯(通行) 三种状态
 */
public class TrafficLight {
    //初始状态红灯
    State state = new Red();
    public void setState(State state) {
        this.state = state;
    }
    //切换为绿灯状态
    public void switchToGreen(){
        state.switchToGreen(this);
    }
    //切换为黄灯状态
    public void switchToYellow(){
        state.switchToYellow(this);
    }
    //切换为红灯状态
    public void switchToRed(){
        state.switchToRed(this);
    }
}

2.2.2.2 交通灯状态接口

java 复制代码

package main.java.cn.test.state.V3;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:14:19
 * @description 交通灯状态接口
 */
public interface State {
    void switchToGreen(TrafficLight trafficLight); //切换为绿灯

    void switchToYellow(TrafficLight trafficLight); //切换为黄灯

    void switchToRed(TrafficLight trafficLight); //切换为红灯

}

2.2.2.3 红灯状态类

java 复制代码

package main.java.cn.test.state.V3;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:16:38
 * @description 红灯状态类
 */
public class Red implements State {
    @Override
    public void switchToGreen(TrafficLight trafficLight) {
        System.out.println("红灯不能切换为绿灯!");
    }

    @Override
    public void switchToYellow(TrafficLight trafficLight) {
        System.out.println("黄灯亮起...时长:10秒!");
    }

    @Override
    public void switchToRed(TrafficLight trafficLight) {
        System.out.println("已是红灯状态无须再切换!");
    }
}

2.2.2.4 黄灯状态类

java 复制代码

package main.java.cn.test.state.V3;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:18:22
 * @description 黄灯状态类
 */
public class Yellow implements State{
    @Override
    public void switchToGreen(TrafficLight trafficLight) {
        System.out.println("绿灯亮起...时长:60秒!");
    }

    @Override
    public void switchToYellow(TrafficLight trafficLight) {
        System.out.println("已是黄灯无须切换!");
    }

    @Override
    public void switchToRed(TrafficLight trafficLight) {
        System.out.println("红灯亮起...时长:90秒!");
    }
}

2.2.2.5 绿灯状态类

java 复制代码

package main.java.cn.test.state.V3;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:17:35
 * @description 绿灯状态类
 */
public class Green implements State{
    @Override
    public void switchToGreen(TrafficLight trafficLight) {
        System.out.println("已是绿灯无须切换!");
    }

    @Override
    public void switchToYellow(TrafficLight trafficLight) {
        System.out.println("黄灯亮起...时长:10秒!");
    }

    @Override
    public void switchToRed(TrafficLight trafficLight) {
        System.out.println("绿灯不能切换为红灯!");
    }
}

2.2.2.6 测试类

java 复制代码

package main.java.cn.test.state.V3;

/**
 * @author ningzhaosheng
 * @date 2024/1/15 12:19:08
 * @description 测试类
 */
public class Test {
    public static void main(String[] args) {
        TrafficLight trafficLight = new TrafficLight();
        trafficLight.switchToYellow();
        trafficLight.switchToGreen();
        trafficLight.switchToRed();
    }
}

通过代码重构，将"状态" 接口化、模块化，最终将它们从臃肿的交通类中抽了出来，消除了原来TrafficLight类中的if...else，代码看起来干净而优雅。

三、状态模式总结

3.1 状态模式的优点

将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

3.2 状态模式的缺点

状态模式的使用必然会增加系统类和对象的个数。
状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
状态模式对"开闭原则"的支持并不太好 (添加新的状态类需要修改那些负责状态转换的源代码)。

3.3 状态模式常见的使用场景

对象根据自身状态的变化来进行不同行为的操作时，比如，购物订单状态。
对象需要根据自身变量的当前值改变行为，不期望使用大量 if-else 语句时，比如，商品库存状态。
对于某些确定的状态和行为，不想使用重复代码时，比如，某一个会员当天的购物浏览记录。

好了，本次分享就到这里，欢迎大家继续阅读《设计模式》专栏其他设计模式内容，如果有帮助到大家，欢迎大家点赞+关注+收藏，有疑问也欢迎大家评论留言！