Mr.Raindrop

// 抽象处理者
public abstract class Approver {
    protected Approver nextApprover;
    public void setNext(Approver next) { this.nextApprover = next; }
    public abstract void handleRequest(LeaveRequest request);
}

// 具体处理者：组长
public class GroupLeader extends Approver {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 2) {
            System.out.println("组长批准请假");
        } else if (nextApprover != null) {
            nextApprover.handleRequest(request); // 传递请求
        }
    }
}

// 客户端构建链
Approver groupLeader = new GroupLeader();
Approver manager = new Manager();
groupLeader.setNext(manager);
groupLeader.handleRequest(new LeaveRequest("张三", 3)); // 转经理处理

// 抽象状态接口：订单状态行为契约 (参考网页2[2](@ref)和网页8[8](@ref))
public interface OrderState {
    void pay(OrderContext context);      // 支付操作
    void cancel(OrderContext context);   // 取消订单
    void ship(OrderContext context);      // 发货操作
    void refund(OrderContext context);    // 申请退款
    void confirmReceipt(OrderContext context); // 确认收货
}

// 待支付
public class PendingPaymentState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        System.out.println("✅ 支付成功，订单进入已支付状态");
        context.setState(new PaidState());
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("❌ 订单已取消");
        context.setState(new CanceledState());
    }

    // 其他操作禁止（参考网页8的状态约束[8](@ref)）
    @Override
    public void ship(OrderContext context) {
        throw new IllegalStateException("待支付订单不能发货");
    }
    // ... 类似实现其他方法的禁止逻辑
}

// 已支付
public class PaidState implements OrderState {
    @Override
    public void ship(OrderContext context) {
        System.out.println("🚚 商品已发货");
        context.setState(new ShippedState());
    }

    @Override
    public void refund(OrderContext context) {
        System.out.println("🔄 退款申请受理中");
        context.setState(new RefundingState());
    }
    
    // 禁止重复支付（参考网页3的状态转换[3](@ref)）
    @Override
    public void pay(OrderContext context) {
        throw new IllegalStateException("已支付订单不能重复付款");
    }
}

// 已发货
public class ShippedState implements OrderState {
    @Override
    public void confirmReceipt(OrderContext context) {
        System.out.println("🎁 确认收货，交易完成");
        context.setState(new CompletedState());
    }

    @Override
    public void refund(OrderContext context) {
        System.out.println("📦 发起退货流程");
        context.setState(new RefundingState());
    }
}

// 上下文类 （订单主体）
public class OrderContext {
    private OrderState currentState;
    private String orderId;

    public OrderContext() {
        this.currentState = new PendingPaymentState(); // 初始状态 待支付
        this.orderId = UUID.randomUUID().toString();
    }

    // 状态转换入口（参考网页2的TransitionTo设计[2](@ref)）
    public void setState(OrderState state) {
        System.out.printf("【状态变更】%s → %s%n", 
            currentState.getClass().getSimpleName(),
            state.getClass().getSimpleName());
        this.currentState = state;
    }

    // 委托操作到当前状态（参考网页3的上下文设计[3](@ref)）
    public void pay() { currentState.pay(this); }
    public void cancel() { currentState.cancel(this); }
    // ... 其他操作委托方法
}

// 客户端调用示例
public class Client {
    public static void main(String[] args) {
        OrderContext order = new OrderContext();
        
        order.pay();       // ✅ 正常支付
        order.ship();      // ✅ 发货操作
        order.pay();       // ❌ 抛出 IllegalStateException
        
        try {
            order.cancel(); // ❌ 已发货订单不可取消
        } catch (Exception e) {
            System.out.println("操作失败: " + e.getMessage());
        }
    }
}

// 抽象类
public abstract class CoffeeMaker {
    // 模板方法（定义算法骨架）
    public final void makeCoffee() {
        boilWater();
        brew();
        pourInCup();
        if (needCondiments()) {
            addCondiments();
        }
    }
    // 基本方法（通用步骤）
    private void boilWater() { System.out.println("烧水"); }
    // 抽象方法（必须由子类实现）
    protected abstract void brew();
    // 钩子方法（可选步骤）
    protected boolean needCondiments() { return true; }
    protected void addCondiments() {} // 默认空实现
}

// 具体子类
public class Americano extends CoffeeMaker {
    @Override
    protected void brew() { System.out.println("冲泡美式咖啡"); }
    @Override
    protected boolean needCondiments() { return false; } // 不添加配料
}

public class PaymentFactory {
 private static final Map<PayTypeEnum, Payment> payStrategies = new HashMap<>();

 static {
     payStrategies.put(PayTypeEnum.WX, new WxPayment());
     payStrategies.put(PayTypeEnum.ALIPAY, new AlipayPayment());
     payStrategies.put(PayTypeEnum.BANK_CARD, new BankCardPayment());
 }

 public static Payment getPayment(PayTypeEnum payType) {
     if (payType == null) {
         throw new IllegalArgumentException("pay type is empty.");
     }
     if (!payStrategies.containsKey(payType)) {
         throw new IllegalArgumentException("pay type not supported.");
     }
     return payStrategies.get(payType);
 }
}

Order order = 订单信息
PayResult payResult = PaymentFactory.getPayment(payType).pay(order);
if (payResult == PayResult.SUCCESS) {
    System.out.println("支付成功");
} else if (payType == 支付宝) {
    System.out.println("支付失败");
}

public abstract class Subject {

    /**
     * 用来保存注册的观察者对象
     */
    private List<Observer> list = new ArrayList<>();

    /**
     * 注册观察者对象
     * @param observer 观察者对象
     */
    public void attach(Observer observer) {
        list.add(observer);
        System.out.println("Attached an observer");
    }

    /**
     * 移除观察者对象
     * @param observer 观察者对象
     */
    public void detach(Observer observer) {
        list.remove(observer);
    }

    /**
     * 通知所有注册的观察者对象
     */
    public void notifyObservers(String newState) {
        for (Observer observer : list) {
            observer.update(newState);
        }
    }
}

public class ConcreteSubject extends Subject {

    private String state;

    public String getState() {
        return state;
    }

    public void change(String newState) {
        state = newState;
        System.out.println("主题状态为：" + state);
        // 状态发生改变，通知各个观察者
        this.notifyObservers(state);
    }

}

public interface Observer {

    /**
     * 更新接口
     * @param state 更新的状态
     */
    void update(String state);

}

public class ConcreteObserver implements Observer {

    // 观察者状态
    private String observerState;

    @Override
    public void update(String state) {
        /**
         * 更新观察者的状态，使其与目标的状态保持一致
         */
        observerState = state;
        System.out.println("状态为：" + observerState);
    }
}

public class Client {

    public static void main(String[] args) {
        // 创建主题对象
        ConcreteSubject subject = new ConcreteSubject();
        // 创建观察者对象
        Observer observer = new ConcreteObserver();
        // 将观察者对象注册到主题对象上
        subject.attach(observer);
        // 改变主题对象的状态
        subject.change("new state");
    }

}