Java 设计模式：订单状态机实现

订单状态机是一种常见的设计模式，它用来描述一个订单在不同阶段的状态转换。在 Java 中，可以使用状态模式来实现订单状态机。

首先，定义一个订单状态接口，包含各种订单状态的方法：

public interface OrderState {
    void confirm(Order order);
    void cancel(Order order);
    void ship(Order order);
    void deliver(Order order);
}

然后，定义各种订单状态的实现类：

public class NewOrderState implements OrderState {
    public void confirm(Order order) {
        order.setState(new ConfirmedOrderState());
    }
    public void cancel(Order order) {
        order.setState(new CancelledOrderState());
    }
    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship a new order');
    }
    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver a new order');
    }
}

public class ConfirmedOrderState implements OrderState {
    public void confirm(Order order) {
        throw new IllegalStateException('Order already confirmed');
    }
    public void cancel(Order order) {
        order.setState(new CancelledOrderState());
    }
    public void ship(Order order) {
        order.setState(new ShippedOrderState());
    }
    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver an unshipped order');
    }
}

public class ShippedOrderState implements OrderState {
    public void confirm(Order order) {
        throw new IllegalStateException('Order already shipped');
    }
    public void cancel(Order order) {
        throw new IllegalStateException('Cannot cancel a shipped order');
    }
    public void ship(Order order) {
        throw new IllegalStateException('Order already shipped');
    }
    public void deliver(Order order) {
        order.setState(new DeliveredOrderState());
    }
}

public class DeliveredOrderState implements OrderState {
    public void confirm(Order order) {
        throw new IllegalStateException('Order already delivered');
    }
    public void cancel(Order order) {
        throw new IllegalStateException('Cannot cancel a delivered order');
    }
    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship a delivered order');
    }
    public void deliver(Order order) {
        throw new IllegalStateException('Order already delivered');
    }
}

public class CancelledOrderState implements OrderState {
    public void confirm(Order order) {
        throw new IllegalStateException('Order already cancelled');
    }
    public void cancel(Order order) {
        throw new IllegalStateException('Order already cancelled');
    }
    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship a cancelled order');
    }
    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver a cancelled order');
    }
}

最后，定义一个订单类，包含当前状态和状态转换方法：

public class Order {
    private OrderState state;
    
    public Order() {
        state = new NewOrderState();
    }
    
    public void setState(OrderState state) {
        this.state = state;
    }
    
    public void confirm() {
        state.confirm(this);
    }
    
    public void cancel() {
        state.cancel(this);
    }
    
    public void ship() {
        state.ship(this);
    }
    
    public void deliver() {
        state.deliver(this);
    }
}

使用订单状态机：

Order order = new Order();
order.confirm();
order.ship();
order.deliver();
order.cancel();

这样，就可以根据订单的状态进行相应的操作，同时保证订单状态转换的正确性。