🧩 Strategy Pattern

✅ Intent

• Treat behavior as a strategy injected from the outside, rather than being determined by internal state
• State transitions are managed externally

✅ Motivation

• Useful when you want to completely separate state from behavior
• Ideal when the focus is purely on switching behavior dynamically

✅ When to Use

• When you don't need state management, and simply want to switch logic at runtime

✅ Code Example

TypeScript

// Strategy インターフェース
interface PublishStrategy {
  publish(): void;
}

// 各戦略
class DraftStrategy implements PublishStrategy {
  publish(): void {
    console.log("レビュー依頼を送信");
  }
}

class ReviewStrategy implements PublishStrategy {
  publish(): void {
    console.log("公開しました");
  }
}

class PublishedStrategy implements PublishStrategy {
  publish(): void {
    console.log("すでに公開済みです");
  }
}

// コンテキスト
class Document {
  constructor(private strategy: PublishStrategy) {}

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

  publish(): void {
    this.strategy.publish();
  }
}

// 利用例
const doc = new Document(new DraftStrategy());
doc.publish(); // → レビュー依頼

doc.setStrategy(new ReviewStrategy());
doc.publish(); // → 公開

doc.setStrategy(new PublishedStrategy());
doc.publish(); // → すでに公開済み

PHP

<?php

interface PublishStrategy {
  public function publish(): void;
}

class DraftStrategy implements PublishStrategy {
  public function publish(): void {
    echo "レビュー依頼を送信\n";
  }
}

class ReviewStrategy implements PublishStrategy {
  public function publish(): void {
    echo "公開しました\n";
  }
}

class PublishedStrategy implements PublishStrategy {
  public function publish(): void {
    echo "すでに公開済みです\n";
  }
}

class Document {
  public function __construct(private PublishStrategy $strategy) {}

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

  public function publish(): void {
    $this->strategy->publish();
  }
}

// 利用例
$doc = new Document(new DraftStrategy());
$doc->publish(); // → レビュー依頼

$doc->setStrategy(new ReviewStrategy());
$doc->publish(); // → 公開

$doc->setStrategy(new PublishedStrategy());
$doc->publish(); // → すでに公開済み

Python

from abc import ABC, abstractmethod

class PublishStrategy(ABC):
    @abstractmethod
    def publish(self):
        pass

class DraftStrategy(PublishStrategy):
    def publish(self):
        print("レビュー依頼を送信")

class ReviewStrategy(PublishStrategy):
    def publish(self):
        print("公開しました")

class PublishedStrategy(PublishStrategy):
    def publish(self):
        print("すでに公開済みです")

class Document:
    def __init__(self, strategy: PublishStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: PublishStrategy):
        self._strategy = strategy

    def publish(self):
        self._strategy.publish()

# 利用例
doc = Document(DraftStrategy())
doc.publish()  # → レビュー依頼

doc.set_strategy(ReviewStrategy())
doc.publish()  # → 公開

doc.set_strategy(PublishedStrategy())
doc.publish()  # → すでに公開済み

✅ Explanation

This code applies the Strategy pattern by extracting the document publishing process into a strategy (PublishStrategy)
that can be dynamically switched at runtime.
The Strategy pattern encapsulates algorithms or operations in separate classes, making them interchangeable.

1. Overview of the Strategy Pattern

• Strategy: Defines a common interface to allow interchangeable behavior

  • Represented by PublishStrategy

• ConcreteStrategy: Implements the strategy interface with specific behavior

  • Represented by DraftStrategy, ReviewStrategy, and PublishedStrategy

• Context: Uses the strategy and allows switching behavior dynamically

  • Represented by Document

2. Key Classes and Their Roles

• PublishStrategy

  • Common interface for publishing behavior
  • Declares the method publish(): void

• DraftStrategy, ReviewStrategy, PublishedStrategy

  • Concrete strategy classes implementing PublishStrategy
  • Provide different publishing behaviors:
    • DraftStrategy: Sends a review request
    • ReviewStrategy: Publishes the document
    • PublishedStrategy: Indicates the document is already published

• Document

  • Context class
  • Receives a PublishStrategy in its constructor and executes the strategy via the publish method
  • Supports dynamic strategy switching via setStrategy

3. UML Class Diagram

4. Benefits of the Strategy Pattern

• Flexibility: Easily switch between different behaviors at runtime
• Single Responsibility Principle: Each strategy is isolated in its own class, improving maintainability
• Extensibility: New strategies can be added simply by implementing PublishStrategy

This design is highly effective when algorithms or operations need to be swapped flexibly,
providing strong support for code extensibility and maintainability.