23种设计模式-状态(State)设计模式

文章目录

一.什么是状态模式？
二.状态模式的结构
三.状态模式的应用场景
四.状态模式的优缺点
五.状态模式的C++实现
六.状态模式的JAVA实现
七.代码解释
八.总结

类图：状态设计模式类图

一.什么是状态模式？

状态模式（State Pattern）是一种行为型设计模式，允许对象在其内部状态改变时改变其行为，看起来就像对象改变了其类。状态模式通过将状态封装为独立的类，使得对象的行为能够根据内部状态动态地改变。
在状态模式中，Context（环境类）持有一个指向State（状态接口）的引用对象，并通过该对象来进行状态切换。具体的状态通过实现状态接口的不同子类来进行封装。

二.状态模式的结构

Context（环境类）：用于维护当前状态，并在特定操作时切换状态。它持有一个State对象的引用，用来对状态进行操作。
State（状态接口）：定义了一个接口，声明了每个具体状态需要实现的行为。
ConcreteStateA 和 ConcreteStateB（具体状态类）：实现State接口的不同子类，表示对象在不同状态下的行为。

三.状态模式的应用场景

对象行为依赖于状态，且状态在运行时变化：如电梯的状态（上升、下降、停止）、游戏角色的状态（跑步、跳跃、静止）。
条件语句过多：当对象中有大量if-else或switch语句判断状态时，可以考虑使用状态模式进行优化。

四.状态模式的优缺点

优点:
- 封装状态转换：将状态与相关行为封装在一个类中，便于维护和扩展。
- 避免条件判断：通过多态替代了条件判断，代码更具可读性和扩展性。
缺点:
- 类数量增加：每个状态需要一个类，可能会导致类数量较多。

五.状态模式的C++实现

#include <iostream>
#include <memory>

// 前置声明，避免循环引用
class State;

// 环境类（Context）
class Context {
private:
    std::shared_ptr<State> state;  // 当前状态

public:
    // 设置当前状态
    void setState(std::shared_ptr<State> newState) {
        state = newState;
    }

    // 执行请求，调用当前状态的Handle方法
    void request();
};

// 状态接口（State）
class State {
public:
    virtual void handle(Context& context) = 0;  // 定义纯虚函数，具体状态类需实现
};

// 具体状态类 A（ConcreteStateA）
class ConcreteStateA : public State {
public:
    void handle(Context& context) override {
        std::cout << "ConcreteStateA handling request.\n";
        // 状态切换：可以切换到状态 B
        context.setState(std::make_shared<ConcreteStateB>());
    }
};

// 具体状态类 B（ConcreteStateB）
class ConcreteStateB : public State {
public:
    void handle(Context& context) override {
        std::cout << "ConcreteStateB handling request.\n";
        // 状态切换：可以切换回状态 A
        context.setState(std::make_shared<ConcreteStateA>());
    }
};

// 环境类方法的实现
void Context::request() {
    if (state) {
        state->handle(*this);  // 调用当前状态的 handle 方法
    }
}

// 测试代码
int main() {
    Context context;
    // 初始化状态为 A
    context.setState(std::make_shared<ConcreteStateA>());

    // 执行多次请求，测试状态切换
    context.request();  // ConcreteStateA 处理请求，然后切换到 ConcreteStateB
    context.request();  // ConcreteStateB 处理请求，然后切换到 ConcreteStateA
    context.request();  // ConcreteStateA 处理请求，然后切换到 ConcreteStateB

    return 0;
}

六.状态模式的JAVA实现

// 抽象状态类
abstract class State {
    public abstract void Handle(Context context);
}

// 具体状态A
class ConcreteStateA extends State {
    @Override
    public void Handle(Context context) {
        System.out.println("ConcreteStateA: Handling request and transitioning to ConcreteStateB.");
        context.setState(new ConcreteStateB());
    }
}

// 具体状态B
class ConcreteStateB extends State {
    @Override
    public void Handle(Context context) {
        System.out.println("ConcreteStateB: Handling request and transitioning to ConcreteStateA.");
        context.setState(new ConcreteStateA());
    }
}

// 环境类 (Context)
class Context {
    private State state;

    public Context(State state) {
        this.state = state;
    }

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

    public void Request() {
        if (state != null) {
            state.Handle(this);
        }
    }
}

// 客户端代码
public class StatePatternDemo {
    public static void main(String[] args) {
        // 初始状态为 ConcreteStateA
        Context context = new Context(new ConcreteStateA());

        // 调用多次 Request，观察状态切换
        context.Request(); // 从 A 切换到 B
        context.Request(); // 从 B 切换到 A
        context.Request(); // 再次从 A 切换到 B
    }
}

七.代码解释

Context 类：
- Context类持有一个指向State的指针（使用智能指针std::shared_ptr来管理状态对象的生命周期）。
- 它包含一个request()方法，用于请求当前状态处理相应的操作。
- setState()方法用于切换状态，方便在运行时改变state的引用指向不同的State对象。
State 接口：
- State接口中定义了一个纯虚函数handle()，表示不同状态下的行为。
- Context通过调用state->handle(*this)来执行当前状态的具体行为。
ConcreteStateA 和 ConcreteStateB：
- ConcreteStateA和ConcreteStateB是State接口的具体实现类，每个类都定义了各自的handle()方法。
- 在ConcreteStateA::handle()中，Context的状态被切换为ConcreteStateB，而在ConcreteStateB::handle()中，状态切换回ConcreteStateA。
- 这种状态切换体现了状态模式的核心思想，即状态内部控制状态转换，客户端不需要关心状态如何切换。
测试代码：
- 在main函数中，创建Context对象context，并将初始状态设为ConcreteStateA。
- 通过多次调用request()方法，可以看到状态在ConcreteStateA和ConcreteStateB之间切换，体现出对象行为随状态变化而变化的特点。