状态模式（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=== 演示结束 ===");
    }
}
相关推荐
喝茶与编码5 小时前
工厂模式+抽象类 实战指南（基于文档导出业务）
设计模式
昨天的猫8 小时前
原来项目中的观察者模式是这样玩的
后端·设计模式
2301_7951672010 小时前
玩转Rust高级应用 如何进行面向对象设计模式的实现，实现状态模式
设计模式·rust·状态模式
星夜泊客20 小时前
Unity 游戏开发中的防御性编程与空值处理实践
unity·设计模式·游戏引擎
Adellle1 天前
设计模式的介绍
设计模式
达斯维达的大眼睛1 天前
设计模式-单列模式
设计模式·cpp
Javatutouhouduan1 天前
记一次redis主从切换导致的数据丢失与陷入只读状态故障
java·redis·设计模式·java面试·高可用·java后端·java程序员
数据知道1 天前
Go语言设计模式：抽象工厂模式详解
设计模式·golang·抽象工厂模式·go语言
数据知道1 天前
Go语言设计模式：组合模式详解
设计模式·golang·组合模式·go语言
有意义1 天前
Spring Boot 项目中部门查询功能实现与依赖注入优化
后端·设计模式
热门推荐
01GitHub 镜像站点02《大数据技术原理与应用》实验报告三 熟悉HBase常用操作03UV安装并设置国内源04综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件05BongoCat - 跨平台键盘猫动画工具06Linux下V2Ray安装配置指南07npm使用国内淘宝镜像的方法08jdk21下载、安装（Windows、Linux、macOS）09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10GitLab 零基础入门指南：从安装到项目管理全流程