🧩 State × Strategy

✅ 組み合わせの意図

• 状態によって処理の可否や振る舞いを切り替えるために State パターンを使用し、
• 実行する戦略（支払方法など）を柔軟に差し替えるために Strategy パターンを併用する

この組み合わせにより、状態遷移と処理内容の両方を分離・柔軟化できる。

✅ よく使われるシーン

• 状態に応じて振る舞いを変えつつ、具体的な処理手段（アルゴリズム）も切り替えたい場合
• 「現在は支払できる状態か？」「支払方法は何か？」という 2 つの軸があるようなシナリオ
• 例：決済処理、会員ステータスに応じた機能制御、予約可否と処理手段の分離など

✅ UML クラス図

✅ コード例

TypeScript

interface PaymentStrategy {
  pay(amount: number): void;
}

class CreditCardPayment implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`[CreditCard] Paid ${amount}`);
  }
}

class PayPalPayment implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`[PayPal] Paid ${amount}`);
  }
}

interface PaymentState {
  handle(amount: number): void;
  setStrategy(strategy: PaymentStrategy): void;
}

class ReadyState implements PaymentState {
  constructor(private strategy: PaymentStrategy) {}

  handle(amount: number): void {
    console.log("Ready to process payment");
    this.strategy.pay(amount);
  }

  setStrategy(strategy: PaymentStrategy): void {
    this.strategy = strategy;
  }
}

class DisabledState implements PaymentState {
  handle(amount: number): void {
    console.log("Payment is currently disabled");
  }

  setStrategy(strategy: PaymentStrategy): void {
    console.log("Cannot set strategy while disabled");
  }
}

class PaymentContext {
  constructor(private state: PaymentState) {}

  setState(state: PaymentState) {
    this.state = state;
  }

  setStrategy(strategy: PaymentStrategy) {
    this.state.setStrategy(strategy);
  }

  pay(amount: number) {
    this.state.handle(amount);
  }
}

// Usage
const context = new PaymentContext(new ReadyState(new CreditCardPayment()));
context.pay(100);

context.setStrategy(new PayPalPayment());
context.pay(200);

context.setState(new DisabledState());
context.pay(300);

PHP

<?php

interface PaymentStrategy {
  public function pay(int $amount): void;
}

class CreditCardPayment implements PaymentStrategy {
  public function pay(int $amount): void {
    echo "[CreditCard] Paid {$amount}\n";
  }
}

class PayPalPayment implements PaymentStrategy {
  public function pay(int $amount): void {
    echo "[PayPal] Paid {$amount}\n";
  }
}

interface PaymentState {
  public function handle(int $amount): void;
  public function setStrategy(PaymentStrategy $strategy): void;
}

class ReadyState implements PaymentState {
  private PaymentStrategy $strategy;

  public function __construct(PaymentStrategy $strategy) {
    $this->strategy = $strategy;
  }

  public function handle(int $amount): void {
    echo "Ready to process payment\n";
    $this->strategy->pay($amount);
  }

  public function setStrategy(PaymentStrategy $strategy): void {
    $this->strategy = $strategy;
  }
}

class DisabledState implements PaymentState {
  public function handle(int $amount): void {
    echo "Payment is currently disabled\n";
  }

  public function setStrategy(PaymentStrategy $strategy): void {
    echo "Cannot set strategy while disabled\n";
  }
}

class PaymentContext {
  private PaymentState $state;

  public function __construct(PaymentState $state) {
    $this->state = $state;
  }

  public function setState(PaymentState $state): void {
    $this->state = $state;
  }

  public function setStrategy(PaymentStrategy $strategy): void {
    $this->state->setStrategy($strategy);
  }

  public function pay(int $amount): void {
    $this->state->handle($amount);
  }
}

// Usage
$context = new PaymentContext(new ReadyState(new CreditCardPayment()));
$context->pay(100);

$context->setStrategy(new PayPalPayment());
$context->pay(200);

$context->setState(new DisabledState());
$context->pay(300);

Python

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount: int) -> None:
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount: int) -> None:
        print(f"[CreditCard] Paid {amount}")

class PayPalPayment(PaymentStrategy):
    def pay(self, amount: int) -> None:
        print(f"[PayPal] Paid {amount}")

class PaymentState(ABC):
    @abstractmethod
    def handle(self, amount: int) -> None:
        pass

    @abstractmethod
    def set_strategy(self, strategy: PaymentStrategy) -> None:
        pass

class ReadyState(PaymentState):
    def __init__(self, strategy: PaymentStrategy):
        self.strategy = strategy

    def handle(self, amount: int) -> None:
        print("Ready to process payment")
        self.strategy.pay(amount)

    def set_strategy(self, strategy: PaymentStrategy) -> None:
        self.strategy = strategy

class DisabledState(PaymentState):
    def handle(self, amount: int) -> None:
        print("Payment is currently disabled")

    def set_strategy(self, strategy: PaymentStrategy) -> None:
        print("Cannot set strategy while disabled")

class PaymentContext:
    def __init__(self, state: PaymentState):
        self.state = state

    def set_state(self, state: PaymentState) -> None:
        self.state = state

    def set_strategy(self, strategy: PaymentStrategy) -> None:
        self.state.set_strategy(strategy)

    def pay(self, amount: int) -> None:
        self.state.handle(amount)

# Usage
context = PaymentContext(ReadyState(CreditCardPayment()))
context.pay(100)

context.set_strategy(PayPalPayment())
context.pay(200)

context.set_state(DisabledState())
context.pay(300)

✅ 解説

• PaymentContext は現在の状態（PaymentState）を保持し、状態に応じた処理を委譲
• ReadyState と DisabledState は State としての役割を果たし、handle メソッドの振る舞いを状態ごとに変える
• Strategy（CreditCardPayment, PayPalPayment）は、支払方法の切り替えを担当
• 実行フロー：
  • PaymentContext が ReadyState なら支払戦略を用いた処理が可能
  • DisabledState なら拒否される

✅ まとめ

• State パターン により、処理の可否や状態遷移のロジックを明確に分離
• Strategy パターン により、可変な処理ロジック（支払方法など）を柔軟に切り替え可能
• 状態と戦略の 2 軸がそれぞれ独立して拡張可能な、保守性の高い構造となる