设计模式Java版：16状态模式（行为型）

定义

状态模式（State Pattern）是一种行为型设计模式，它允许对象在内部状态改变时改变其行为。状态模式将对象的行为封装在不同的状态对象中，并将状态的变化作为对象间的转换，以实现更灵活、可扩展的状态管理。

在状态模式中，主要包含以下角色：

1. 上下文（Context）：是包含状态的对象，它在运行时可以切换不同的状态对象，从而改变自身的行为。上下文将状态的操作委托给当前状态对象来处理。
2. 状态（State）：是抽象类或接口，定义了状态的行为接口，包括可能发生的操作方法。不同的具体状态类实现了不同的状态行为。
3. 具体状态（Concrete State）：是状态的具体实现类，实现了状态的具体行为。每个具体状态类负责处理特定状态下的操作。

状态模式的核心思想是将复杂的条件分支语句转化为基于多态的状态类。通过将状态的行为封装在不同的状态对象中，状态模式使得对象的状态转换更加灵活、可扩展，并且符合开闭原则。状态模式可以使得代码结构更清晰，减少了条件语句的使用，使得代码更加可读、可维护。

使用状态模式时，需要考虑状态的切换逻辑、状态之间的转换规则以及上下文与状态之间的协作。状态模式适用于当对象的行为依赖于其状态，并且状态会在运行时发生改变的情况，以及当有多个相关的条件判断时，可以考虑使用状态模式来简化代码逻辑。

总结起来，状态模式通过将对象的行为封装在不同的状态对象中，实现对象行为的动态切换，提供了一种简洁、可扩展的状态管理机制。

示例一：电梯系统

以下是一个简单的Java示例代码，演示了使用状态模式实现一个电梯的行为管理：

首先，定义上下文类（Context）和状态接口（State）：

// 状态接口
interface State {
    void handleRequest();
}

// 上下文类
class ElevatorContext {
    private State currentState;

    public ElevatorContext() {
        // 初始状态设置为停止状态
        currentState = new StoppedState();
    }

    public void setState(State state) {
        currentState = state;
    }

    public void request() {
        currentState.handleRequest();
    }
}

然后，实现具体的状态类：

// 停止状态
class StoppedState implements State {
    @Override
    public void handleRequest() {
        System.out.println("电梯停止，等待指令...");
    }
}

// 运行状态
class RunningState implements State {
    @Override
    public void handleRequest() {
        System.out.println("电梯正在运行...");
    }
}

// 停止状态
class OpeningState implements State {
    @Override
    public void handleRequest() {
        System.out.println("电梯门开启...");
    }
}

// 停止状态
class ClosingState implements State {
    @Override
    public void handleRequest() {
        System.out.println("电梯门关闭...");
    }
}

最后，使用状态模式进行测试：

public class Main {
    public static void main(String[] args) {
        ElevatorContext context = new ElevatorContext();

        // 初始状态为停止状态
        context.request();

        // 切换到运行状态
        context.setState(new RunningState());
        context.request();

        // 切换到开门状态
        context.setState(new OpeningState());
        context.request();

        // 切换到关门状态
        context.setState(new ClosingState());
        context.request();
    }
}

运行上述代码，将输出以下结果：

电梯停止，等待指令...
电梯正在运行...
电梯门开启...
电梯门关闭...

以上示例展示了一个简单的电梯系统，通过状态模式实现了不同状态下电梯的行为切换。根据当前的状态，电梯可以处理不同的请求，使得代码结构更加清晰和可扩展。

示例二：订单系统

以下是一个生活中常见的状态模式的例子，以表示订单在不同状态下的行为管理：

首先，定义上下文类（OrderContext）和状态接口（OrderState）：

// 状态接口
interface OrderState {
    void processOrder();
}

// 上下文类
class OrderContext {
    private OrderState currentState;

    public OrderContext() {
        // 初始状态设置为新订单状态
        currentState = new NewOrderState();
    }

    public void setState(OrderState state) {
        currentState = state;
    }

    public void processOrder() {
        currentState.processOrder();
    }
}

然后，实现具体的状态类：

// 新订单状态
class NewOrderState implements OrderState {
    @Override
    public void processOrder() {
        System.out.println("处理新订单...");
    }
}

// 等待付款状态
class WaitingPaymentState implements OrderState {
    @Override
    public void processOrder() {
        System.out.println("等待付款...");
    }
}

// 准备发货状态
class ReadyToShipState implements OrderState {
    @Override
    public void processOrder() {
        System.out.println("准备发货...");
    }
}

// 已发货状态
class ShippedState implements OrderState {
    @Override
    public void processOrder() {
        System.out.println("已发货...");
    }
}

最后，使用状态模式进行测试：

public class Main {
    public static void main(String[] args) {
        OrderContext context = new OrderContext();

        // 初始状态为新订单状态
        context.processOrder();

        // 切换到等待付款状态
        context.setState(new WaitingPaymentState());
        context.processOrder();

        // 切换到准备发货状态
        context.setState(new ReadyToShipState());
        context.processOrder();

        // 切换到已发货状态
        context.setState(new ShippedState());
        context.processOrder();
    }
}

运行上述代码，将输出以下结果：

处理新订单...
等待付款...
准备发货...
已发货...

以上示例展示了一个订单系统，在不同的状态下对订单进行不同的处理。通过状态模式，订单根据当前的状态执行相应的操作，使得代码结构更加清晰和可扩展。生活中的订单状态变化是常见的，使用状态模式可以方便地管理和处理不同状态下的行为。