状态模式（State Pattern）是一种行为设计模式，它允许一个对象在其内部状态改变时改变其行为，使对象看起来像是修改了其类。状态模式可以有效地将状态相关的行为和状态转换逻辑封装到独立的状态类中，使得状态转换更加明确、代码更加清晰和易于维护。
使用场景
-
对象的行为取决于其状态
当一个对象的行为会根据其内部状态发生改变时，可以使用状态模式来处理不同状态下的行为。示例：在一个文档编辑器中，文档可能处于编辑状态、只读状态或锁定状态，不同的状态下用户的操作行为不同。
-
状态转换较复杂且有多个状态
当一个对象有多个状态，并且状态之间的转换较为复杂时，可以使用状态模式将每个状态的行为和状态转换逻辑封装在独立的类中。示例：在一个电梯系统中，电梯可以处于上升、下降、静止等状态，不同状态下电梯的行为和下一步的状态转换逻辑不同。
-
避免大量的条件语句
当需要通过大量的条件语句来处理状态转换时，可以使用状态模式将状态相关的行为和逻辑分散到独立的状态类中，简化条件语句的使用。示例：在一个视频播放器中，视频可能处于播放、暂停、停止等状态，可以使用状态模式来避免在一个方法中处理所有的状态转换。
UML类图
+-------------------+ +-------------------+
| Context |<>---->| State |
+-------------------+ +-------------------+
| -state: State | | +handle() |
| +setState() | +-------------------+
| +request() | /|\
+-------------------+ |
|
+-------------------+
| ConcreteStateA |
+-------------------+
| +handle() |
+-------------------+
/|\
|
+-------------------+
| ConcreteStateB |
+-------------------+
| +handle() |
+-------------------+
类图解释
-
Context（上下文）：
- 职责：维护一个
State对象的实例，这个实例定义了当前的状态。 - 属性：持有一个
State类型的成员变量state。 - 方法：
setState(State state)：设置当前的状态。request()：调用当前状态的handle方法。
- 职责：维护一个
-
State（抽象状态类）：
- 职责：定义一个接口，以封装与
Context的一个特定状态相关的行为。 - 方法：
handle()：具体状态类需要实现这个方法来处理相应的行为。
- 职责：定义一个接口，以封装与
-
ConcreteStateA（具体状态类A）：
- 职责：实现
State接口，处理Context处于状态 A 时的行为。 - 方法：
handle()：定义Context在状态 A 时的行为。
- 职责：实现
-
ConcreteStateB（具体状态类B）：
- 职责：实现
State接口，处理Context处于状态 B 时的行为。 - 方法：
handle()：定义Context在状态 B 时的行为。
- 职责：实现
具体解释
-
Context：这是系统中持有状态的类。它维护一个
State对象，这个对象表示当前的状态。Context提供了setState方法来切换状态，并通过request方法来触发当前状态的行为。 -
State：这是一个抽象类或接口，定义了所有具体状态类需要实现的方法。在这个模式中，它包含了一个
handle方法，用于处理状态对应的行为。 -
ConcreteStateA 和 ConcreteStateB：这些是具体的状态类，它们实现了
State接口。每个具体状态类都实现了handle方法，根据不同的状态执行不同的行为。
状态模式的工作流程
- 初始化状态：
Context被初始化时，通常会设置一个初始状态。 - 处理请求：当客户端调用
Context的request方法时，Context会调用当前状态对象的handle方法来处理请求。 - 状态切换：在某些情况下，
handle方法会触发状态切换，通过调用Context的setState方法将Context切换到另一个状态。 - 新状态处理：状态切换后，
Context的request方法会调用新的状态对象的handle方法来处理后续的请求。
示例代码
假设我们有一个简单的电灯，它可以处于开（On）和关（Off）两种状态。我们用状态模式来实现这个场景。
#include <iostream>
#include <memory>
// 抽象状态类
class State {
public:
virtual void handle() = 0;
virtual ~State() = default;
};
// 环境类
class Context {
public:
Context(std::unique_ptr<State> state) : state_(std::move(state)) {}
void setState(std::unique_ptr<State> state) {
state_ = std::move(state);
}
void request() {
state_->handle();
}
private:
std::unique_ptr<State> state_;
};
// 具体状态类：打开状态
class OnState : public State {
public:
void handle() override {
std::cout << "The light is on." << std::endl;
}
};
// 具体状态类：关闭状态
class OffState : public State {
public:
void handle() override {
std::cout << "The light is off." << std::endl;
}
};
// 客户端代码
int main() {
Context context(std::make_unique<OffState>());
// 切换到打开状态
context.request();
context.setState(std::make_unique<OnState>());
context.request();
// 切换到关闭状态
context.setState(std::make_unique<OffState>());
context.request();
return 0;
}
代码解读
- 抽象状态类（State）：定义了一个
handle方法，所有具体状态类需要实现这个方法。 - 具体状态类（OnState 和 OffState）：实现了
State接口，分别处理打开和关闭状态的行为。 - 环境类（Context）：持有一个
State对象，可以动态设置和改变其状态，并通过调用状态对象的handle方法来处理当前状态的行为。 - 客户端代码：创建一个初始状态为
OffState的环境对象，并通过setState方法切换状态，通过request方法调用当前状态的行为。
优点
-
遵循开闭原则：
可以在不修改现有代码的情况下，添加新的状态类，增加系统的扩展性。 -
状态转换清晰：
将状态相关的行为和状态转换逻辑封装在独立的状态类中，使状态转换更加清晰。 -
减少条件语句：
使用状态模式可以避免在一个方法中使用大量的条件语句来处理不同的状态，简化代码逻辑。 -
提高代码可维护性：
将状态相关的行为分散到独立的状态类中，提高代码的可读性和可维护性。
缺点
-
增加类的数量：
使用状态模式会增加类的数量，每个状态都需要定义一个具体状态类。 -
状态转换逻辑分散：
状态转换逻辑分散在各个状态类中，可能会导致系统的复杂性增加。 -
可能造成性能开销：
状态的频繁切换可能会带来性能开销，特别是在状态切换逻辑较复杂时。
使用场景总结
- 对象的行为取决于其状态：如文档编辑器中的编辑、只读和锁定状态。
- 状态转换较复杂且有多个状态：如电梯系统中的上升、下降和静止状态。
- 避免大量的条件语句：如视频播放器中的播放、暂停和停止状态。
通过这些示例和解释，可以看到状态模式在处理对象的状态转换、简化条件语句和提高系统扩展性方面的强大功能。
状态模式稍微复杂一点的例子
假设我们要设计一个简单的文本编辑器，它有以下几种状态：
- 编辑模式（Editing State）：用户可以在文档中输入和修改文本。
- 选择模式（Selecting State）：用户可以选择文本。
- 只读模式（Read-Only State）：用户只能查看文本，不能修改。
每种模式下，用户对键盘和鼠标的操作会有不同的响应。我们用状态模式来实现这个场景。
UML类图
+-------------------+ +-------------------+
| Context |<>---->| State |
+-------------------+ +-------------------+
| -state: State | | +handleInput() |
| +setState() | | +handleMouse() |
| +handleInput() | +-------------------+
| +handleMouse() | /|\
+-------------------+ |
|
+--------------------------+--------------------------+
| | |
| | |
+-------------------+ +-------------------+ +-------------------+
| ConcreteStateA | | ConcreteStateB | | ConcreteStateC |
| (EditingState) | | (SelectingState) | | (ReadOnlyState) |
+-------------------+ +-------------------+ +-------------------+
| +handleInput() | | +handleInput() | | +handleInput() |
| +handleMouse() | | +handleMouse() | | +handleMouse() |
+-------------------+ +-------------------+ +-------------------+
代码实现
我们来实现这个文本编辑器的状态模式。
#include <iostream>
#include <memory>
// 抽象状态类
class State {
public:
virtual void handleInput() = 0;
virtual void handleMouse() = 0;
virtual ~State() = default;
};
// 环境类
class Context {
public:
Context(std::unique_ptr<State> state) : state_(std::move(state)) {}
void setState(std::unique_ptr<State> state) {
state_ = std::move(state);
}
void handleInput() {
state_->handleInput();
}
void handleMouse() {
state_->handleMouse();
}
private:
std::unique_ptr<State> state_;
};
// 具体状态类：编辑状态
class EditingState : public State {
public:
void handleInput() override {
std::cout << "EditingState: Handling input for editing." << std::endl;
}
void handleMouse() override {
std::cout << "EditingState: Handling mouse for editing." << std::endl;
}
};
// 具体状态类：选择状态
class SelectingState : public State {
public:
void handleInput() override {
std::cout << "SelectingState: Handling input for selecting." << std::endl;
}
void handleMouse() override {
std::cout << "SelectingState: Handling mouse for selecting." << std::endl;
}
};
// 具体状态类：只读状态
class ReadOnlyState : public State {
public:
void handleInput() override {
std::cout << "ReadOnlyState: Ignoring input in read-only mode." << std::endl;
}
void handleMouse() override {
std::cout << "ReadOnlyState: Handling mouse in read-only mode." << std::endl;
}
};
// 客户端代码
int main() {
Context context(std::make_unique<ReadOnlyState>());
// 当前状态：只读状态
context.handleInput();
context.handleMouse();
// 切换到编辑状态
context.setState(std::make_unique<EditingState>());
context.handleInput();
context.handleMouse();
// 切换到选择状态
context.setState(std::make_unique<SelectingState>());
context.handleInput();
context.handleMouse();
return 0;
}
代码解读
- 抽象状态类（State）：定义了
handleInput和handleMouse方法，所有具体状态类需要实现这两个方法。 - 具体状态类（EditingState, SelectingState, ReadOnlyState）：实现了
State接口，分别处理不同状态下的键盘输入和鼠标操作。 - 环境类（Context）：持有一个
State对象，可以动态设置和改变其状态，并通过调用状态对象的handleInput和handleMouse方法来处理当前状态的行为。 - 客户端代码：创建一个初始状态为
ReadOnlyState的环境对象，通过setState方法切换状态，并通过handleInput和handleMouse方法调用当前状态的行为。
通过这个更复杂的例子，我们展示了状态模式如何将对象的行为与其内部状态分离，并使状态转换更加清晰和可维护。
3406
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
