十八、行为型（状态模式）

状态模式（State Pattern）

概念

状态模式是一种行为型设计模式，允许一个对象在其内部状态改变时改变其行为。这个模式将状态的相关行为封装在独立的状态类中，使得状态之间的切换更加灵活。通过状态模式，您可以将复杂的状态逻辑分散到多个状态类中，从而提高系统的可维护性和可扩展性。

应用场景

状态转移复杂的对象：当一个对象的行为依赖于其状态，并且可能会在运行时改变其状态时，使用状态模式可以清晰地管理这些状态及其行为。
工作流管理：在一些工作流系统中，任务的状态可能会频繁变化，使用状态模式可以有效地管理不同状态下的任务行为。
游戏开发：在游戏开发中，角色的状态（如走、跑、跳、攻击）会影响其行为，状态模式可以使这些行为更加灵活。
UI组件状态：在用户界面设计中，组件的状态（如启用、禁用、显示、隐藏）会影响其行为，状态模式可以帮助管理这些状态变化。

注意点

状态类数量：状态模式的使用可能会导致状态类的数量增加，增加系统的复杂性。
过度使用：如果状态变化不频繁或状态行为相对简单，可能不需要使用状态模式，简单的条件判断可能更为高效。
状态与上下文的耦合：状态类与上下文类之间的耦合可能会增加，设计时需要考虑解耦的策略。

核心要素

Context（上下文）：维护对某个具体状态对象的引用，负责管理当前状态。
State（状态接口）：定义状态的接口，通常包括一些行为方法。
ConcreteState（具体状态）：实现状态接口的具体状态类，定义在特定状态下的行为。

Java代码完整示例

示例：简单的状态模式实现

java 复制代码

// 状态接口
interface State {
    void handle(Context context);
}

// 上下文类
class Context {
    private State state;

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

    public void request() {
        state.handle(this);
    }
}

// 具体状态类：状态A
class ConcreteStateA implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Handling request in State A");
        context.setState(new ConcreteStateB()); // 切换到状态B
    }
}

// 具体状态类：状态B
class ConcreteStateB implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Handling request in State B");
        context.setState(new ConcreteStateA()); // 切换到状态A
    }
}

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

        // 设置初始状态
        context.setState(new ConcreteStateA());

        // 发起请求，状态会在内部切换
        context.request();
        context.request();
        context.request();
    }
}

输出结果：

复制代码

Handling request in State A
Handling request in State B
Handling request in State A

各种变形用法完整示例

多状态之间的复杂转换

在某些情况下，状态之间的转换规则可能会更复杂，您可以在状态类中引入条件判断来决定下一个状态。

代码示例：复杂状态转换

java 复制代码

// 具体状态类：状态A
class ComplexStateA implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Handling request in Complex State A");
        // 根据某些条件决定状态转换
        if (Math.random() > 0.5) {
            context.setState(new ConcreteStateB());
        } else {
            context.setState(new ConcreteStateC());
        }
    }
}

// 具体状态类：状态C
class ConcreteStateC implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Handling request in State C");
        context.setState(new ConcreteStateA()); // 切换回状态A
    }
}

// 客户端代码
public class ComplexStateDemo {
    public static void main(String[] args) {
        Context context = new Context();
        context.setState(new ComplexStateA());

        for (int i = 0; i < 5; i++) {
            context.request();
        }
    }
}

状态模式与命令模式结合

在某些情况下，可以将状态模式与命令模式结合，允许命令在不同状态下表现出不同的行为。

代码示例：状态与命令结合

java 复制代码

// 增加命令接口
interface Command {
    void execute();
}

// 增加状态命令实现
class StateCommand implements Command {
    private Context context;

    public StateCommand(Context context) {
        this.context = context;
    }

    @Override
    public void execute() {
        context.request();
    }
}

// 客户端代码
public class StateAndCommandDemo {
    public static void main(String[] args) {
        Context context = new Context();
        context.setState(new ConcreteStateA());

        Command command = new StateCommand(context);
        command.execute(); // 执行命令
        command.execute(); // 执行命令
    }
}

状态的持久化

在某些应用场景中，状态需要持久化，可以将状态保存到数据库中，并在恢复时重建状态对象。

代码示例：状态持久化

java 复制代码

// 增加状态枚举
enum StateType {
    STATE_A, STATE_B
}

// 上下文类
class PersistentContext {
    private State state;

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

    public StateType saveState() {
        if (state instanceof ConcreteStateA) {
            return StateType.STATE_A;
        } else {
            return StateType.STATE_B;
        }
    }

    public void restoreState(StateType stateType) {
        if (stateType == StateType.STATE_A) {
            setState(new ConcreteStateA());
        } else {
            setState(new ConcreteStateB());
        }
    }
}

public class StatePersistenceDemo {
    public static void main(String[] args) {
        PersistentContext context = new PersistentContext();
        context.restoreState(StateType.STATE_A);

        // 执行操作并保存状态
        System.out.println("Saved State: " + context.saveState());
    }
}

通过这些示例，状态模式的灵活性和应用场景得以体现，能够根据具体需求实现多种变形用法。