状态模式（State Pattern）

李广坤2025-10-10 17:55

状态模式（State Pattern） 是一种行为型设计模式，它允许一个对象在其内部状态改变时改变其行为。该模式将每个状态封装成独立的类，使得对象看起来像是"改变了它的类"。

💡 核心思想：把条件判断逻辑转化为对象之间的委托与切换

java 复制代码 
/**
 * 订单状态接口 - 状态模式核心
 * 每个具体状态实现此接口以定义该状态下的行为
 */
public interface OrderState {
    void pay(OrderContext context);
    void ship(OrderContext context);
    void deliver(OrderContext context);
    void complete(OrderContext context);
    void cancel(OrderContext context);
}
java 复制代码 
/**
 * 待支付状态
 */
public class PendingState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        System.out.println("订单支付成功");
        context.setState(context.getPaidState());
    }

    @Override
    public void ship(OrderContext context) {
        throw new IllegalStateException("订单未支付，无法发货");
    }

    @Override
    public void deliver(OrderContext context) {
        throw new IllegalStateException("订单未发货，无法送达");
    }

    @Override
    public void complete(OrderContext context) {
        throw new IllegalStateException("订单未送达，无法完成");
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("订单已取消");
        context.setState(context.getCancelledState());
    }
}
java 复制代码 
/**
 * 已支付状态
 */
public class PaidState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        throw new IllegalStateException("订单已支付，无需重复支付");
    }

    @Override
    public void ship(OrderContext context) {
        System.out.println("订单已发货");
        context.setState(context.getShippedState());
    }

    @Override
    public void deliver(OrderContext context) {
        throw new IllegalStateException("订单未发货，无法送达");
    }

    @Override
    public void complete(OrderContext context) {
        throw new IllegalStateException("订单未送达，无法完成");
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("订单已取消，退款处理中");
        context.setState(context.getCancelledState());
    }
}
java 复制代码 
/**
 * 已发货状态
 */
public class ShippedState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        throw new IllegalStateException("订单已支付，无法再次支付");
    }

    @Override
    public void ship(OrderContext context) {
        throw new IllegalStateException("订单已发货，无需重复发货");
    }

    @Override
    public void deliver(OrderContext context) {
        System.out.println("订单已送达");
        context.setState(context.getDeliveredState());
    }

    @Override
    public void complete(OrderContext context) {
        throw new IllegalStateException("订单未送达，无法完成");
    }

    @Override
    public void cancel(OrderContext context) {
        throw new IllegalStateException("订单已发出，无法取消");
    }
}
java 复制代码 
/**
 * 已送达状态
 */
public class DeliveredState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        throw new IllegalStateException("订单已支付，无法再次支付");
    }

    @Override
    public void ship(OrderContext context) {
        throw new IllegalStateException("订单已发货，无需重复发货");
    }

    @Override
    public void deliver(OrderContext context) {
        throw new IllegalStateException("订单已送达，无需重复送达");
    }

    @Override
    public void complete(OrderContext context) {
        System.out.println("订单已完成");
        context.setState(context.getCompletedState());
    }

    @Override
    public void cancel(OrderContext context) {
        throw new IllegalStateException("订单已完成，无法取消");
    }
}
java 复制代码 
/**
 * 已完成状态
 */
public class CompletedState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        throw new IllegalStateException("订单已完成，无法支付");
    }

    @Override
    public void ship(OrderContext context) {
        throw new IllegalStateException("订单已完成，无法发货");
    }

    @Override
    public void deliver(OrderContext context) {
        throw new IllegalStateException("订单已完成，无法送达");
    }

    @Override
    public void complete(OrderContext context) {
        throw new IllegalStateException("订单已完成，无需重复完成");
    }

    @Override
    public void cancel(OrderContext context) {
        throw new IllegalStateException("订单已完成，无法取消");
    }
}
java 复制代码 
/**
 * 已取消状态
 */
public class CancelledState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        throw new IllegalStateException("订单已取消，无法支付");
    }

    @Override
    public void ship(OrderContext context) {
        throw new IllegalStateException("订单已取消，无法发货");
    }

    @Override
    public void deliver(OrderContext context) {
        throw new IllegalStateException("订单已取消，无法送达");
    }

    @Override
    public void complete(OrderContext context) {
        throw new IllegalStateException("订单已取消，无法完成");
    }

    @Override
    public void cancel(OrderContext context) {
        throw new IllegalStateException("订单已取消，无需重复取消");
    }
}
java 复制代码 
/**
 * 订单上下文类，持有当前状态并委托行为到状态实现
 */
public class OrderContext {
    private OrderState currentState;
    private final PendingState pendingState = new PendingState();
    private final PaidState paidState = new PaidState();
    private final ShippedState shippedState = new ShippedState();
    private final DeliveredState deliveredState = new DeliveredState();
    private final CompletedState completedState = new CompletedState();
    private final CancelledState cancelledState = new CancelledState();
    private String orderId;

    public OrderContext(String orderId) {
        this.orderId = orderId;
        this.currentState = pendingState;
    }

    public OrderState getCurrentState() {
        return currentState;
    }

    public void setState(OrderState state) {
        System.out.println("订单 " + orderId + " 状态变更: " + this.currentState.getClass().getSimpleName() + " -> " + state.getClass().getSimpleName());
        this.currentState = state;
    }

    // Getter methods for state instances
    public PendingState getPendingState() {
        return pendingState;
    }

    public PaidState getPaidState() {
        return paidState;
    }

    public ShippedState getShippedState() {
        return shippedState;
    }

    public DeliveredState getDeliveredState() {
        return deliveredState;
    }

    public CompletedState getCompletedState() {
        return completedState;
    }

    public CancelledState getCancelledState() {
        return cancelledState;
    }

    // Delegated behavior methods
    public void pay() {
        currentState.pay(this);
    }

    public void ship() {
        currentState.ship(this);
    }

    public void deliver() {
        currentState.deliver(this);
    }

    public void complete() {
        currentState.complete(this);
    }

    public void cancel() {
        currentState.cancel(this);
    }
}
java 复制代码 
/**
 * 状态模式示例：订单状态机
 * 演示如何使用状态模式管理订单生命周期
 */
public class OrderStatePatternExample {
    
    public static void main(String[] args) {
        System.out.println("=== 订单状态模式演示 ===");
        
        // 创建订单
        OrderContext order = new OrderContext("ORD-20230001");
        System.out.println("初始状态: " + order.getCurrentState().getClass().getSimpleName());

        try {
            // 正常流程：待支付 -> 已支付 -> 已发货 -> 已送达 -> 已完成
            System.out.println("\n--- 正常订单流程 ---");
            order.pay();
            order.ship();
            order.deliver();
            order.complete();

            // 尝试非法操作
            System.out.println("\n--- 测试非法操作 ---");
            System.out.println("尝试再次支付...");
            order.pay(); // 应该抛出异常

        } catch (IllegalStateException e) {
            System.out.println("拦截非法操作: " + e.getMessage());
        }

        // 创建新订单测试取消流程
        System.out.println("\n--- 取消订单流程 ---");
        OrderContext cancelOrder = new OrderContext("ORD-20230002");
        System.out.println("初始状态: " + cancelOrder.getCurrentState().getClass().getSimpleName());
        cancelOrder.cancel();
        System.out.println("最终状态: " + cancelOrder.getCurrentState().getClass().getSimpleName());
        
        try {
            System.out.println("尝试支付已取消订单...");
            cancelOrder.pay(); // 应该抛出异常
        } catch (IllegalStateException e) {
            System.out.println("拦截非法操作: " + e.getMessage());
        }
        
        System.out.println("\n=== 演示结束 ===");
    }
}
相关推荐
李广坤8 小时前
观察者模式（Observer Pattern）
设计模式
李广坤8 小时前
中介者模式（Mediator Pattern）
设计模式
李广坤9 小时前
迭代器模式（Iterator Pattern）
设计模式
李广坤9 小时前
解释器模式（Interpreter Pattern）
设计模式
阿无，12 小时前
java23种设计模式之前言
设计模式
Asort13 小时前
JavaScript设计模式(八)：组合模式(Composite)——构建灵活可扩展的树形对象结构
前端·javascript·设计模式
数据智能老司机13 小时前
数据工程设计模式——数据基础
大数据·设计模式·架构
笨手笨脚の15 小时前
设计模式-代理模式
设计模式·代理模式·aop·动态代理·结构型设计模式
Overboom1 天前
[C++] --- 常用设计模式
开发语言·c++·设计模式
热门推荐
01两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答02GitHub 镜像站点03UV安装并设置国内源0446个Nano-banana 精选提示词，持续更新中05Linux下V2Ray安装配置指南06智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践07GitLab 零基础入门指南：从安装到项目管理全流程08Cursor Plan Mode：AI 终于知道先想后做了09一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示10jdk21下载、安装（Windows、Linux、macOS）