笨蛋学设计模式行为型模式-状态模式【20】

8.7状态模式

8.7.1概念

? 状态模式是指对象在运行时可以根据内部状态的不同而改变它们的行为，该模式将内部状态的行为封装为不同的具体状态类中，并将状态转换逻辑委托给这些状态类来处理，当对象的内部状态发生变化时，它会自动切换到对应的状态类，从而改变其行为。

8.7.2场景

? 比如在设计一个电梯系统时，可以使用状态模式来管理电梯的不同状态，如开门、关门、上升、下降等。将电梯的这几种状态封装成一个独立的状态类，并定义了该状态下的具体行为，通过将状态切换的逻辑分布到各个状态类中，可以使得电梯的状态切换更加清晰、易于维护和扩展。

8.7.3优势 / 劣势

• 代码结构清晰：将每个状态切换的逻辑都封装到各个独立的状态类中，使得代码更加清晰
• 遵循开闭原则：通过新增一个新的状态类，可以轻松地扩展系统的功能

---

• 代码可能过于冗余：若状态类过多或者状态转移过于复杂，会导致系统的类数量增加
• 过于抽象：状态模式比较抽象，不太容易理解

8.7.4状态模式可分为

• 状态State：定义一个接口，用于封装与Context的一个特定状态相关的行为
• 具体状态ConcreteState：负责处理Context在状态改变时的行为，每一个具体状态子类实现一个与Context的一个状态相关的行为
• 上下文Context：维护一个具体状态子类的实例，这个实例定义当前的状态

8.7.5状态模式

package com.technologystatck.designpattern.mode.state;

public class States {
    public static void main(String[] args) {
        Context context = new Context();
        State state1 = new ConcreteState1();
        State state2 = new ConcreteState2();

        context.setState(state1);
        //执行在状态1下的操作
        context.request();

        context.setState(state2);
        //执行在状态2下的操作
        context.request();
        
    }
}

//定义状态接口
interface State{
    void handle();
}

//实现具体状态类：为对象可能的每种状态创建具体的状态类，
//实现状态接口中定义的方法

//具体状态类1
class ConcreteState1 implements State{

    @Override
    public void handle() {
        //执行在状态1下的操作
        System.out.println("执行在状态1下的操作");
    }
}
//具体状态类2
class ConcreteState2 implements State{

    @Override
    public void handle() {
        //执行在状态2下的操作
        System.out.println("执行在状态2下的操作");
    }
}
//创建上下文类：该类包含对状态的引用，并在需要时调用当前状态的方法
class Context{
    private State currentState;

    //根据不同的状态类，调用不同的状态类方法
    public void setState(State state){
        this.currentState=state;
    }

    public void request(){
        currentState.handle();  //调用状态对象中的方法，完成状态的转换
    }
}

8.7.6实战

8.7.6.1题目描述

小明家有一个灯泡，刚开始为关闭状态（OffState）。台灯可以接收一系列的指令，包括打开（“ON”）、关闭（“OFF”）和闪烁（“blink”）。每次接收到一个指令后，台灯会执行相应的操作，并输出当前灯泡的状态。请设计一个程序模拟这个灯泡系统。

8.7.6.2输入描述

第一行是一个整数 n（1 <= n <= 1000），表示接收的命令数量。

接下来的 n 行，每行包含一个字符串 s，表示一个命令（“ON”、“OFF"或"blink”）。

8.7.6.3输出描述

对于每个命令，输出一行，表示执行该命令后灯泡的状态。

8.7.6.4代码

package com.technologystatck.designpattern.mode.state;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int nums = scanner.nextInt();
        scanner.nextLine();

        //实例化灯泡类
        Light light = new Light();

        for (int i = 0; i < nums; i++) {
            String command = scanner.nextLine().trim();

            //根据输入修改灯的状态
            switch (command) {
                //根据不同的状态使用不同的灯泡
                case "ON":
                    light.setState(new OnBulbState());
                    break;
                case "OFF":
                    light.setState(new OffBulbState());
                    break;
                case "BLINK":
                    light.setState(new BlinkBulbState());
                    break;
                default:
                    System.out.println("Invalid command: "+command);
                    break;
            }
            //显示灯的当前状态
            System.out.println(light.performOperation());
        }
    }
}


//定义状态接口
interface TableLampState {
    String handle();
}

//定义具体的状态类
//打开台灯
class OnBulbState implements TableLampState {

    @Override
    public String handle() {
        return "Light is ON";
    }
}

//关闭台灯
class OffBulbState implements TableLampState {

    @Override
    public String handle() {
        return "Light is OFF";
    }
}

//台灯闪烁
class BlinkBulbState implements TableLampState {

    @Override
    public String handle() {
        return "Light is Blink";
    }
}

//上下文类
class Light {
    //当前状态类的状态
    private TableLampState state;

    public Light() {
        //初始状态为关闭
        this.state = new OffBulbState();
    }

    //设置新的状态

    public void setState(TableLampState state) {
        this.state = state;
    }

    //执行状态转换
    public String performOperation() {
        return state.handle();
    }
}

8.7.7总结

• 优点：状态模式使的代码结构更加清晰化，同时更方便我们对代码结构进行扩展
• 总结：将对象的每个状态封装成一个类，通过给类增加对应状态的行为，来实现对象的状态操作
• 场景：适用于有限状态机的场景，其中对象的行为在运行时可以根据内部的状态改变而改变