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("支払いタイプが空です。");
     }
     if (!payStrategies.containsKey(payType)) {
         throw new IllegalArgumentException("支払いタイプはサポートされていません。");
     }
     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("オブザーバーが追加されました");
    }

    /**
     * オブザーバーオブジェクトを削除します
     * @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("新しい状態");
    }

}