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");
    }

}