Python设计模式详解之21 ——状态模式

State（状态）设计模式详解

State（状态）设计模式 是一种行为型设计模式，允许对象在其内部状态改变时改变其行为。此模式的核心思想是将状态逻辑抽象到独立的状态类中，从而使得状态转换更加清晰，且容易维护。

---

1. 定义

State 模式将状态封装成独立的类，并将状态之间的切换逻辑交给这些类来处理，而不是由上下文（Context）类直接管理状态逻辑。这种模式可以避免复杂的 if-else 或 switch-case 分支，并实现状态切换的扩展性。

---

2. 适用场景

1. 对象的行为依赖于它的状态，并且在运行时需要根据状态切换行为。
2. 状态的逻辑复杂，且多个状态之间的切换需要解耦。
3. 希望避免使用繁琐的条件判断语句来管理状态。

---

3. 结构

1. Context（上下文）

   • 维护当前状态的引用，并将请求委托给当前状态对象。

2. State（抽象状态）

   • 定义状态的接口，具体状态类需要实现该接口。

3. ConcreteState（具体状态）

   • 实现状态对应的具体行为。

---

4. Python 实现

以下是一个自动售货机的示例，展示如何使用 State 模式来管理状态。

示例：自动售货机

from abc import ABC, abstractmethod

# 抽象状态
class State(ABC):
    @abstractmethod
    def insert_coin(self):
        pass

    @abstractmethod
    def select_item(self):
        pass

    @abstractmethod
    def dispense(self):
        pass

# 具体状态：等待投币
class WaitingForCoinState(State):
    def __init__(self, context):
        self.context = context

    def insert_coin(self):
        print("Coin inserted. You can select an item now.")
        self.context.set_state(self.context.has_coin_state)

    def select_item(self):
        print("Please insert a coin first.")

    def dispense(self):
        print("No coin inserted. Unable to dispense.")

# 具体状态：已投币
class HasCoinState(State):
    def __init__(self, context):
        self.context = context

    def insert_coin(self):
        print("Coin already inserted. Please select an item.")

    def select_item(self):
        print("Item selected. Dispensing now...")
        self.context.set_state(self.context.dispensing_state)

    def dispense(self):
        print("Please select an item first.")

# 具体状态：正在出货
class DispensingState(State):
    def __init__(self, context):
        self.context = context

    def insert_coin(self):
        print("Dispensing in progress. Please wait.")

    def select_item(self):
        print("Dispensing in progress. Please wait.")

    def dispense(self):
        print("Item dispensed. Thank you!")
        self.context.set_state(self.context.waiting_for_coin_state)

# 上下文
class VendingMachineContext:
    def __init__(self):
        self.waiting_for_coin_state = WaitingForCoinState(self)
        self.has_coin_state = HasCoinState(self)
        self.dispensing_state = DispensingState(self)

        self.current_state = self.waiting_for_coin_state

    def set_state(self, state):
        self.current_state = state

    def insert_coin(self):
        self.current_state.insert_coin()

    def select_item(self):
        self.current_state.select_item()

    def dispense(self):
        self.current_state.dispense()

# 客户端
if __name__ == "__main__":
    vending_machine = VendingMachineContext()

    vending_machine.select_item()   # Output: Please insert a coin first.
    vending_machine.insert_coin()  # Output: Coin inserted. You can select an item now.
    vending_machine.insert_coin()  # Output: Coin already inserted. Please select an item.
    vending_machine.select_item()  # Output: Item selected. Dispensing now...
    vending_machine.insert_coin()  # Output: Dispensing in progress. Please wait.
    vending_machine.dispense()     # Output: Item dispensed. Thank you!
    vending_machine.select_item()  # Output: Please insert a coin first.

---

5. 优点和缺点

优点

1. 简化复杂状态逻辑：通过将状态逻辑分离到不同的类中，避免了上下文类中冗长的条件语句。
2. 遵循开闭原则：可以通过添加新的状态类来扩展行为，而无需修改现有代码。
3. 提高可维护性：状态类的职责单一，易于维护和测试。

缺点

1. 类的数量增加：每个状态都需要一个独立的类，可能导致类数量膨胀。
2. 状态切换需要依赖上下文：上下文与状态类存在一定的耦合。

---

6. 扩展用法

6.1 游戏角色状态管理

在游戏中，角色的行为可能因状态（如站立、奔跑、跳跃）不同而发生变化。State 模式可用于管理这些状态及其切换。

class CharacterState(ABC):
    @abstractmethod
    def handle_input(self, context, input):
        pass

class StandingState(CharacterState):
    def handle_input(self, context, input):
        if input == "run":
            print("Switching to Running State.")
            context.set_state(context.running_state)
        elif input == "jump":
            print("Switching to Jumping State.")
            context.set_state(context.jumping_state)

class RunningState(CharacterState):
    def handle_input(self, context, input):
        if input == "stop":
            print("Switching to Standing State.")
            context.set_state(context.standing_state)

class JumpingState(CharacterState):
    def handle_input(self, context, input):
        if input == "land":
            print("Switching to Standing State.")
            context.set_state(context.standing_state)

class Character:
    def __init__(self):
        self.standing_state = StandingState()
        self.running_state = RunningState()
        self.jumping_state = JumpingState()

        self.current_state = self.standing_state

    def set_state(self, state):
        self.current_state = state

    def handle_input(self, input):
        self.current_state.handle_input(self, input)

if __name__ == "__main__":
    character = Character()

    character.handle_input("run")   # Output: Switching to Running State.
    character.handle_input("stop")  # Output: Switching to Standing State.
    character.handle_input("jump")  # Output: Switching to Jumping State.
    character.handle_input("land")  # Output: Switching to Standing State.

6.2 基于状态的工作流

State 模式可用于工作流管理系统，处理不同阶段的任务，例如任务从“待处理”到“进行中”再到“已完成”的状态切换。

---

7. 总结

State 模式通过将状态逻辑抽象到独立的类中，使得对象行为在状态变化时可以动态切换。这种设计模式非常适合管理复杂的状态机或状态转换逻辑。尽管实现时会增加类的数量，但这种解耦方式提高了代码的可维护性和扩展性。