24. 状态模式

原文地址: 状态模式更多内容请关注：智想天开

1. 状态模式简介

状态模式（State Pattern）是一种行为型设计模式，它允许一个对象在其内部状态改变时改变其行为，使得该对象看起来似乎修改了其类。状态模式通过将状态的行为封装到独立的状态类中，实现了对象行为的动态切换，避免了大量的条件判断语句（如if-else或switch-case）。

关键点：

状态封装：将不同的状态及其对应的行为封装到独立的状态类中。
动态切换：对象可以在运行时根据内部状态切换其行为。
单一职责：每个状态类负责其特定状态下的行为，实现了职责的明确划分。
避免条件判断：通过多态性替代条件判断，提升代码的可维护性和可扩展性。

2. 状态模式的意图

状态模式的主要目的是：

封装状态相关的行为：将对象的不同状态及其对应的行为封装到独立的状态类中。
实现对象行为的动态切换：允许对象在运行时根据内部状态切换其行为，而无需修改对象的类。
简化复杂的条件判断：通过状态类的多态性，避免在对象方法中使用大量的条件判断语句。
提高系统的可维护性和可扩展性：通过清晰的职责划分和开放/封闭原则，便于系统的维护和功能的扩展。
支持状态的可复用性：独立的状态类可以在多个上下文中复用，提升代码的复用性。

3. 状态模式的结构

3.1. 结构组成

状态模式主要由以下四个角色组成：

Context（上下文）：维护一个具体状态对象的引用，定义了客户端所感兴趣的接口。上下文的行为依赖于当前的状态对象，并通过委托给当前状态对象来执行相应的行为。
State（状态接口）：定义了一个接口，用于封装与上下文的一个特定状态相关的行为。
ConcreteState（具体状态）：实现了State接口，定义了与上下文的一个特定状态相关的行为。
Client（客户端）：创建一个上下文对象并初始化其状态。

角色关系：

Context 持有一个 State 对象的引用。
State 接口由多个 ConcreteState 类实现。
ConcreteState 实现了与特定状态相关的行为，并可以根据需要切换上下文的状态。
Client 与 Context 交互，触发状态的变化。

3.2. UML类图

以下是状态模式的简化UML类图：

+-----------------+          +----------------------------+          +------------------+
|     Client      |          |    Context                 |          |     State        |
+-----------------+          +----------------------------+          +------------------+
|                 |<>------->| - state: State             |          | + handle(): void |
|                 |          +----------------------------+          +------------------+
|                 |          | + setState(s: State): void |                  ^
|                 |          | + request(): void          |                  |
|                 |          +----------------------------+                  |
+-----------------+                                                          ||+-----------------+|ConcreteStateA   |+-----------------+| + handle(): void|+-----------------+|+-----------------+|ConcreteStateB   |+-----------------+| + handle(): void|+-----------------+

说明：

Client 通过调用 Context 的 request() 方法来触发状态相关的行为。
Context 委托给当前的 State 对象来执行行为。
ConcreteStateA 和 ConcreteStateB 实现了 State 接口，并在 handle() 方法中定义了具体的行为和可能的状态切换。

4. 状态模式的实现

状态模式的实现需要确保上下文对象能够根据内部状态动态切换行为。以下示例将展示如何在Java和Python中实现状态模式。以一个简单的电灯开关为例，实现电灯的开关状态管理。

4.1. Java 实现示例

示例说明

我们将实现一个简单的电灯开关系统，电灯有开（On）和关（Off）两种状态。通过状态模式，实现电灯状态的切换和相应的行为执行。

代码实现

// State接口
public interface State {void handle();
}// ConcreteStateA类（开状态）
public class OnState implements State {@Overridepublic void handle() {System.out.println("电灯已经开启。");}
}// ConcreteStateB类（关状态）
public class OffState implements State {@Overridepublic void handle() {System.out.println("电灯已经关闭。");}
}// Context类
public class LightSwitch {private State currentState;public LightSwitch() {// 初始状态为关this.currentState = new OffState();}public void setState(State state) {this.currentState = state;}public void press() {currentState.handle();// 状态切换if (currentState instanceof OffState) {setState(new OnState());} else {setState(new OffState());}}
}// 客户端代码
public class StatePatternDemo {public static void main(String[] args) {LightSwitch lightSwitch = new LightSwitch();lightSwitch.press(); // 打开电灯lightSwitch.press(); // 关闭电灯lightSwitch.press(); // 打开电灯lightSwitch.press(); // 关闭电灯}
}

输出

电灯已经关闭。
电灯已经开启。
电灯已经关闭。
电灯已经开启。

代码说明

State接口：定义了电灯状态的行为接口 handle()。
OnState类（ConcreteStateA）：实现了 handle() 方法，表示电灯开启时的行为。
OffState类（ConcreteStateB）：实现了 handle() 方法，表示电灯关闭时的行为。
LightSwitch类（Context）：维护当前的状态对象，初始状态为关闭。press() 方法触发当前状态的行为，并根据当前状态切换到另一状态。
StatePatternDemo类：客户端，创建了电灯开关对象，并模拟了多次按下开关的过程。

4.2. Python 实现示例

示例说明

同样，实现一个简单的电灯开关系统，电灯有开（On）和关（Off）两种状态。通过状态模式，实现电灯状态的切换和相应的行为执行。

代码实现

from abc import ABC, abstractmethod# State抽象类
class State(ABC):@abstractmethoddef handle(self):pass# ConcreteStateA类（开状态）
class OnState(State):def handle(self):print("电灯已经开启。")# ConcreteStateB类（关状态）
class OffState(State):def handle(self):print("电灯已经关闭。")# Context类
class LightSwitch:def __init__(self):# 初始状态为关self._state = OffState()def set_state(self, state: State):self._state = statedef press(self):self._state.handle()# 状态切换if isinstance(self._state, OffState):self.set_state(OnState())else:self.set_state(OffState())# 客户端代码
def state_pattern_demo():light_switch = LightSwitch()light_switch.press()  # 打开电灯light_switch.press()  # 关闭电灯light_switch.press()  # 打开电灯light_switch.press()  # 关闭电灯if __name__ == "__main__":state_pattern_demo()

输出

电灯已经关闭。
电灯已经开启。
电灯已经关闭。
电灯已经开启。

代码说明

State抽象类：定义了电灯状态的行为接口 handle()。
OnState类（ConcreteStateA）：实现了 handle() 方法，表示电灯开启时的行为。
OffState类（ConcreteStateB）：实现了 handle() 方法，表示电灯关闭时的行为。
LightSwitch类（Context）：维护当前的状态对象，初始状态为关闭。press() 方法触发当前状态的行为，并根据当前状态切换到另一状态。
state_pattern_demo函数：客户端，创建了电灯开关对象，并模拟了多次按下开关的过程。

5. 状态模式的适用场景

状态模式适用于以下场景：

对象的行为取决于其状态：对象的行为随着其内部状态的变化而变化，且对象必须根据当前状态改变其行为。
需要避免大量的条件判断：当对象的行为需要依赖于大量的条件判断时，状态模式可以通过状态类的多态性简化代码。
状态转换频繁且复杂：当对象的状态转换频繁且复杂，状态模式可以通过封装状态类来管理状态转换。
需要动态切换对象的状态：在运行时根据对象的内部状态动态地切换行为。
需要明确划分状态相关的行为：通过状态类的独立，实现职责的明确划分，增强代码的可维护性。

示例应用场景：

电灯开关系统：根据电灯的当前状态（开/关）执行不同的操作。
游戏角色状态管理：角色的行为（如移动、攻击）根据当前状态（如正常、受伤、死亡）而变化。
TCP协议状态管理：TCP连接的状态（如建立、关闭、监听）影响其行为。
订单处理系统：订单的状态（如新建、处理中、已完成、已取消）决定其处理流程。
文档编辑器：根据文档的状态（如只读、编辑、保存）限制或允许不同的操作。

6. 状态模式的优缺点

6.1. 优点

封装性强：将与特定状态相关的行为封装到独立的状态类中，确保职责的明确划分。
简化复杂的条件判断：通过多态性替代大量的if-else或switch-case语句，提升代码的可读性和可维护性。
增强系统的灵活性和可扩展性：可以方便地增加新的状态类，而无需修改现有的上下文类或其他状态类。
支持状态的可复用性：独立的状态类可以在不同的上下文中复用，提升代码的复用性。
遵循开闭原则：系统对扩展开放，对修改关闭，通过添加新的状态类实现功能的扩展。

6.2. 缺点

增加类的数量：每个状态需要一个独立的状态类，可能导致系统中类的数量增加，增加了设计的复杂性。
系统设计复杂：状态模式的实现涉及多个类和接口，需要较好的设计才能确保系统的清晰和可维护性。
上下文类可能较复杂：上下文类需要维护当前的状态对象，并在必要时切换状态，可能增加上下文类的复杂性。
状态之间可能存在耦合：某些实现可能导致不同状态类之间存在耦合关系，影响系统的灵活性。
调试难度增加：多个状态类的存在可能使得系统的调试变得更加复杂，特别是在状态转换频繁的情况下。

7. 状态模式的常见误区与解决方案

7.1. 误区1：过度使用状态模式

问题描述：开发者可能倾向于将所有可能的状态和相关行为都通过状态模式实现，导致系统中充斥着大量的状态类，增加了系统的复杂性和维护成本。

解决方案：

评估必要性：仅在确实需要对象行为依赖于状态且状态变化复杂的场景下使用状态模式。
合理设计状态类：确保每个状态类的职责单一，避免状态类之间的重复和冗余。
结合其他模式：在适当的情况下，结合使用其他设计模式（如策略模式），实现更灵活的设计。

7.2. 误区2：忽视状态类的内聚性

问题描述：状态类可能因为职责不明确或功能混乱，导致内聚性差，影响系统的可维护性和可扩展性。

解决方案：

明确职责：每个状态类只负责与其特定状态相关的行为，遵循单一职责原则。
高内聚低耦合：确保状态类内部的实现高度内聚，与其他状态类之间保持低耦合。
使用接口和抽象类：通过接口或抽象类定义状态行为，确保状态类的行为一致性。

7.3. 误区3：状态类之间存在不必要的依赖

问题描述：状态类之间可能由于设计不当，存在不必要的依赖关系，导致系统的耦合度增加。

解决方案：

设计松散耦合的状态类：状态类应独立实现，不依赖于其他状态类。
通过上下文类管理状态切换：由上下文类负责管理状态对象的切换，避免状态类直接引用或依赖其他状态类。
遵循开闭原则：通过接口或抽象类定义状态行为，使得状态类之间不直接依赖具体实现。

8. 状态模式的实际应用实例

8.1. 游戏角色状态管理

示例说明

在游戏中，角色可能有多种状态，如正常、受伤、死亡等。通过状态模式，实现角色状态的管理和相应行为的切换。

Java实现示例

// State接口
public interface CharacterState {void handle();
}// ConcreteStateA类（正常状态）
public class NormalState implements CharacterState {@Overridepublic void handle() {System.out.println("角色处于正常状态，可以自由移动和攻击。");}
}// ConcreteStateB类（受伤状态）
public class InjuredState implements CharacterState {@Overridepublic void handle() {System.out.println("角色受伤，移动速度减慢，攻击力降低。");}
}// ConcreteStateC类（死亡状态）
public class DeadState implements CharacterState {@Overridepublic void handle() {System.out.println("角色已死亡，无法进行任何操作。");}
}// Context类
public class GameCharacter {private CharacterState currentState;public GameCharacter() {// 初始状态为正常this.currentState = new NormalState();}public void setState(CharacterState state) {this.currentState = state;}public void performAction() {currentState.handle();}
}// 客户端代码
public class StatePatternGameDemo {public static void main(String[] args) {GameCharacter character = new GameCharacter();character.performAction(); // 正常状态character.setState(new InjuredState());character.performAction(); // 受伤状态character.setState(new DeadState());character.performAction(); // 死亡状态}
}

输出

角色处于正常状态，可以自由移动和攻击。
角色受伤，移动速度减慢，攻击力降低。
角色已死亡，无法进行任何操作。

代码说明

CharacterState接口：定义了角色状态的行为接口 handle()。
NormalState类（ConcreteStateA）：实现了 handle() 方法，表示角色处于正常状态时的行为。
InjuredState类（ConcreteStateB）：实现了 handle() 方法，表示角色受伤状态时的行为。
DeadState类（ConcreteStateC）：实现了 handle() 方法，表示角色死亡状态时的行为。
GameCharacter类（Context）：维护当前的状态对象，初始状态为正常。performAction() 方法触发当前状态的行为。
StatePatternGameDemo类：客户端，创建了游戏角色对象，并演示了状态的切换和行为的执行。

8.2. TCP连接状态管理

示例说明

在TCP协议中，连接具有多种状态，如建立、监听、关闭等。通过状态模式，实现TCP连接状态的管理和相应行为的切换。

Python实现示例

from abc import ABC, abstractmethod# State抽象类
class TCPState(ABC):@abstractmethoddef open(self, tcp):pass@abstractmethoddef close(self, tcp):pass@abstractmethoddef acknowledge(self, tcp):pass# ConcreteStateA类（Closed状态）
class ClosedState(TCPState):def open(self, tcp):print("TCP连接正在打开...")tcp.set_state(OpenState())def close(self, tcp):print("TCP连接已经关闭。")def acknowledge(self, tcp):print("TCP连接尚未打开，无法确认。")# ConcreteStateB类（Open状态）
class OpenState(TCPState):def open(self, tcp):print("TCP连接已经打开。")def close(self, tcp):print("TCP连接正在关闭...")tcp.set_state(ClosedState())def acknowledge(self, tcp):print("TCP连接确认成功。")# Context类
class TCPConnection:def __init__(self):self._state = ClosedState()def set_state(self, state: TCPState):self._state = statedef open(self):self._state.open(self)def close(self):self._state.close(self)def acknowledge(self):self._state.acknowledge(self)# 客户端代码
def state_pattern_tcp_demo():tcp = TCPConnection()tcp.acknowledge()  # 尝试确认，尚未打开tcp.open()         # 打开连接tcp.acknowledge()  # 确认连接tcp.close()        # 关闭连接tcp.acknowledge()  # 尝试确认，已关闭if __name__ == "__main__":state_pattern_tcp_demo()

输出

TCP连接尚未打开，无法确认。
TCP连接正在打开...
TCP连接确认成功。
TCP连接正在关闭...
TCP连接尚未打开，无法确认。

代码说明

TCPState抽象类：定义了TCP连接状态的行为接口 open(), close(), 和 acknowledge()。
ClosedState类（ConcreteStateA）：实现了 open(), close(), 和 acknowledge() 方法，表示TCP连接关闭状态时的行为。
OpenState类（ConcreteStateB）：实现了 open(), close(), 和 acknowledge() 方法，表示TCP连接打开状态时的行为。
TCPConnection类（Context）：维护当前的状态对象，初始状态为关闭。open(), close(), 和 acknowledge() 方法委托给当前状态对象。
state_pattern_tcp_demo函数：客户端，创建了TCP连接对象，并演示了状态的切换和行为的执行。

8.3. 订单处理系统的状态管理

示例说明

在电子商务系统中，订单可能经历多个状态，如新建、处理中、已发货、已完成、已取消等。通过状态模式，实现订单状态的管理和相应行为的切换。

Java实现示例

// State接口
public interface OrderState {void handle(OrderContext context);
}// ConcreteStateA类（新建状态）
public class NewState implements OrderState {@Overridepublic void handle(OrderContext context) {System.out.println("订单已创建，等待处理。");context.setState(new ProcessingState());}
}// ConcreteStateB类（处理中状态）
public class ProcessingState implements OrderState {@Overridepublic void handle(OrderContext context) {System.out.println("订单正在处理中。");context.setState(new ShippedState());}
}// ConcreteStateC类（已发货状态）
public class ShippedState implements OrderState {@Overridepublic void handle(OrderContext context) {System.out.println("订单已发货。");context.setState(new CompletedState());}
}// ConcreteStateD类（已完成状态）
public class CompletedState implements OrderState {@Overridepublic void handle(OrderContext context) {System.out.println("订单已完成。");}
}// ConcreteStateE类（已取消状态）
public class CancelledState implements OrderState {@Overridepublic void handle(OrderContext context) {System.out.println("订单已取消。");}
}// Context类
public class OrderContext {private OrderState currentState;public OrderContext() {this.currentState = new NewState();}public void setState(OrderState state) {this.currentState = state;}public void process() {currentState.handle(this);}// 取消订单的方法public void cancel() {if (!(currentState instanceof CompletedState) && !(currentState instanceof CancelledState)) {setState(new CancelledState());System.out.println("订单被取消。");} else {System.out.println("无法取消订单，订单已完成或已取消。");}}
}// 客户端代码
public class StatePatternOrderDemo {public static void main(String[] args) {OrderContext order = new OrderContext();order.process(); // 新建 -> 处理中order.process(); // 处理中 -> 已发货order.cancel();  // 已发货 -> 已取消order.process(); // 已取消，无法继续处理}
}

输出

订单已创建，等待处理。
订单正在处理中。
订单已发货。
无法取消订单，订单已完成或已取消。

代码说明

OrderState接口：定义了订单状态的行为接口 handle()。
NewState类（ConcreteStateA）：实现了 handle() 方法，表示订单新建状态时的行为，并切换到处理中状态。
ProcessingState类（ConcreteStateB）：实现了 handle() 方法，表示订单处理中状态时的行为，并切换到已发货状态。
ShippedState类（ConcreteStateC）：实现了 handle() 方法，表示订单已发货状态时的行为，并切换到已完成状态。
CompletedState类（ConcreteStateD）：实现了 handle() 方法，表示订单已完成状态时的行为。
CancelledState类（ConcreteStateE）：实现了 handle() 方法，表示订单已取消状态时的行为。
OrderContext类（Context）：维护当前的状态对象，初始状态为新建。process() 方法委托给当前状态对象执行行为。cancel() 方法用于取消订单，根据当前状态决定是否可以取消。
StatePatternOrderDemo类：客户端，创建了订单对象，并演示了订单状态的切换和取消操作。