行为型模式-状态模式

状态模式模式是什么

    状态模式是一种行为型设计模式，它允许对象在内部状态发生改变时改变它的行为。在状态模式中，对象的行为是基于当前状态来决定的，对象会根据不同的状态来执行不同的操作。这样可以将复杂的状态逻辑封装在具体的状态类中，使得代码更加可维护、可扩展，并且符合开闭原则。

在状态模式中，有三个核心角色：

1. 环境类（Context）：持有一个具体状态类的实例，用于维护当前状态，并提供对外的接口来改变状态。

2. 抽象状态类（State）：定义了一个接口，用于封装具体状态类的行为。

3. 具体状态类（ConcreteState）：实现了抽象状态类的接口，在不同的状态下具有不同的行为。

状态模式优缺点

优点：

1. 将状态的逻辑封装在具体的状态类中，使得状态的变化更加清晰可见，易于理解和维护。
2. 增加新的状态类或修改现有状态类不会影响到其他状态类，符合开闭原则。
3. 避免了大量的条件语句判断状态，提高代码的可读性和可维护性。
4. 可以将状态转换逻辑集中化，减少代码的冗余。

缺点：

1. 如果状态类较多，可能会导致类的数量增加，增加代码的复杂性。
2. 如果状态之间的转换逻辑较为复杂，可能导致状态类的设计变得复杂。
3. 状态模式可能会增加一些类和对象的数量，增加了系统的复杂性。

状态模式应用场景

1. 对象的行为取决于它的状态，并且需要在运行时根据状态改变行为。
2. 对象的行为包含大量的条件判断语句，并且这些条件判断语句随着状态的不同而变化。
3. 对象的行为需要根据状态的改变而改变，但是并不希望将状态的变化和行为的实现混在一起。

例如，考虑一个交通信号灯的控制系统。信号灯有红灯、黄灯和绿灯三种状态。状态模式可以用来处理信号灯不同状态下的行为。在红灯状态下，信号灯只能显示红灯，车辆必须停下；在黄灯状态下，信号灯只能显示黄灯，车辆准备停下；在绿灯状态下，信号灯只能显示绿灯，车辆可以通行。通过使用状态模式，可以将不同状态的行为封装在不同的状态类中，使得代码更加清晰和可维护。

代码示例

// 定义电梯状态接口
interface ElevatorState {
    void openDoor();
    void closeDoor();
    void goUp();
    void goDown();
}

// 电梯关闭状态类
class ClosedState implements ElevatorState {
    @Override
    public void openDoor() {
        System.out.println("Opening door...");
        // 切换到开门状态
        ElevatorContext.getInstance().changeState(new OpenedState());
    }

    @Override
    public void closeDoor() {
        System.out.println("Door is already closed");
    }

    @Override
    public void goUp() {
        System.out.println("Going up...");
        // 切换到上升状态
        ElevatorContext.getInstance().changeState(new GoingUpState());
    }

    @Override
    public void goDown() {
        System.out.println("Going down...");
        // 切换到下降状态
        ElevatorContext.getInstance().changeState(new GoingDownState());
    }
}

// 电梯开门状态类
class OpenedState implements ElevatorState {
    @Override
    public void openDoor() {
        System.out.println("Door is already opened");
    }

    @Override
    public void closeDoor() {
        System.out.println("Closing door...");
        // 切换到关闭状态
        ElevatorContext.getInstance().changeState(new ClosedState());
    }

    @Override
    public void goUp() {
        System.out.println("Cannot go up while door is opened");
    }

    @Override
    public void goDown() {
        System.out.println("Cannot go down while door is opened");
    }
}

// 电梯上升状态类
class GoingUpState implements ElevatorState {
    @Override
    public void openDoor() {
        System.out.println("Cannot open door while going up");
    }

    @Override
    public void closeDoor() {
        System.out.println("Cannot close door while going up");
    }

    @Override
    public void goUp() {
        System.out.println("Already going up");
    }

    @Override
    public void goDown() {
        System.out.println("Going down...");
        // 切换到下降状态
        ElevatorContext.getInstance().changeState(new GoingDownState());
    }
}

// 电梯下降状态类
class GoingDownState implements ElevatorState {
    @Override
    public void openDoor() {
        System.out.println("Cannot open door while going down");
    }

    @Override
    public void closeDoor() {
        System.out.println("Cannot close door while going down");
    }

    @Override
    public void goUp() {
        System.out.println("Going up...");
        // 切换到上升状态
        ElevatorContext.getInstance().changeState(new GoingUpState());
    }

    @Override
    public void goDown() {
        System.out.println("Already going down");
    }
}

// 电梯上下文类
class ElevatorContext {
    private ElevatorState currentState;
    private static ElevatorContext instance;

    private ElevatorContext() {
        // 初始状态为关闭状态
        currentState = new ClosedState();
    }

    public static ElevatorContext getInstance() {
        if (instance == null) {
            instance = new ElevatorContext();
        }
        return instance;
    }

    public void changeState(ElevatorState state) {
        currentState = state;
    }

    public void openDoor() {
        currentState.openDoor();
    }

    public void closeDoor() {
        currentState.closeDoor();
    }

    public void goUp() {
        currentState.goUp();
    }

    public void goDown() {
        currentState.goDown();
    }
}

// 示例代码
public class Main {
    public static void main(String[] args) {
        ElevatorContext elevator = ElevatorContext.getInstance();

        // 电梯初始状态为关闭状态
        elevator.closeDoor();

        // 电梯开始上升
        elevator.goUp();

        // 电梯开门
        elevator.openDoor();

        // 电梯关闭门
        elevator.closeDoor();

        // 电梯开始下降
        elevator.goDown();
    }
}

这段代码使用了状态模式来模拟电梯的行为。电梯有四个状态：关闭、开门、上升和下降。每个状态实现了相应的操作方法。ElevatorContext类负责管理电梯的状态，并在状态切换时调用相应的方法。主函数中演示了电梯的各种操作。

总结

状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变其行为。状态模式将对象的行为封装在不同的状态类中，对象根据其当前状态决定采取的行动。

在状态模式中，通常有三个主要角色：上下文（Context），抽象状态（Abstract State）和具体状态（Concrete State）。

上下文（Context）是包含状态的对象，它可以根据其当前状态来执行相应的行为。上下文可以将请求委派给具体状态对象，同时也可以在状态之间切换。

抽象状态（Abstract State）是所有具体状态类的基类，它定义了一个接口，用于在具体状态类中实现不同的行为。

具体状态（Concrete State）是实现抽象状态接口的具体类，每个具体状态类都对应于上下文的一个状态，当上下文的状态改变时，具体状态类的行为也会相应改变。

状态模式的核心思想是将复杂的条件判断逻辑分散到各个状态类中，使得每个状态类的代码更加简洁和可维护。同时，状态模式也提供了一种简单的方法来扩展和添加新的状态，而不需要修改上下文类的代码。

使用状态模式可以带来如下好处：

1. 将与特定状态相关的行为局部化，并将不同状态的行为分散到各个具体状态类中，提高代码的可读性和可维护性。

2. 通过定义新的具体状态类来扩展状态，不需要修改上下文类的代码。

3. 状态模式符合开闭原则，能够轻松添加新的状态类，而无需修改现有代码。

状态模式的缺点是会增加类和对象的数量，因为每个具体状态类都需要一个对应的类。同时，状态模式也可能增加了系统的复杂性。