🧩 State Pattern

✅ Intent

• Represent an object's state as dedicated classes, with behavior defined per state
• The current state directly determines which behavior to execute

✅ Motivation

• Separates behavior per state into classes, ensuring clear responsibility separation
• Since each state object knows the transition rules, state control is explicit and manageable

✅ When to Use

• For UI or business flows involving steps, transitions, or mode switching
• When many states are expected and future expansion is likely

✅ Code Example

TypeScript

// 状態インターフェース
interface DocumentState {
  publish(context: DocumentContext): void;
}

// 状態クラス（draft）
class DraftState implements DocumentState {
  publish(context: DocumentContext): void {
    console.log("レビュー依頼を送信");
    context.setState(new ReviewState());
  }
}

// 状態クラス（review）
class ReviewState implements DocumentState {
  publish(context: DocumentContext): void {
    console.log("公開しました");
    context.setState(new PublishedState());
  }
}

// 状態クラス（published）
class PublishedState implements DocumentState {
  publish(context: DocumentContext): void {
    console.log("すでに公開済みです");
  }
}

// コンテキスト
class DocumentContext {
  private state: DocumentState;

  constructor() {
    this.state = new DraftState();
  }

  setState(state: DocumentState): void {
    this.state = state;
  }

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

// 利用例
const doc = new DocumentContext();
doc.publish(); // → レビュー依頼
doc.publish(); // → 公開
doc.publish(); // → すでに公開済み

PHP

<?php

interface DocumentState {
  public function publish(DocumentContext $context): void;
}

class DraftState implements DocumentState {
  public function publish(DocumentContext $context): void {
    echo "レビュー依頼を送信\n";
    $context->setState(new ReviewState());
  }
}

class ReviewState implements DocumentState {
  public function publish(DocumentContext $context): void {
    echo "公開しました\n";
    $context->setState(new PublishedState());
  }
}

class PublishedState implements DocumentState {
  public function publish(DocumentContext $context): void {
    echo "すでに公開済みです\n";
  }
}

class DocumentContext {
  private DocumentState $state;

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

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

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

// 利用例
$doc = new DocumentContext();
$doc->publish(); // → レビュー依頼
$doc->publish(); // → 公開
$doc->publish(); // → すでに公開済み

Python

from abc import ABC, abstractmethod

class DocumentState(ABC):
    @abstractmethod
    def publish(self, context: "DocumentContext"):
        pass

class DraftState(DocumentState):
    def publish(self, context: "DocumentContext"):
        print("レビュー依頼を送信")
        context.set_state(ReviewState())

class ReviewState(DocumentState):
    def publish(self, context: "DocumentContext"):
        print("公開しました")
        context.set_state(PublishedState())

class PublishedState(DocumentState):
    def publish(self, context: "DocumentContext"):
        print("すでに公開済みです")

class DocumentContext:
    def __init__(self):
        self._state: DocumentState = DraftState()

    def set_state(self, state: DocumentState):
        self._state = state

    def publish(self):
        self._state.publish(self)

# 利用例
doc = DocumentContext()
doc.publish()  # → レビュー依頼
doc.publish()  # → 公開
doc.publish()  # → すでに公開済み

✅ Explanation

This code applies the State pattern to switch behavior based on the document's state (Draft, Review, Published).
The State pattern allows an object to change its behavior based on its internal state, eliminating conditional branches and improving readability and maintainability.

1. Overview of the State Pattern

• State: Interface defining behavior for each state

  • Represented by DocumentState in this code

• ConcreteState: Implements the State interface and provides state-specific behavior

  • Represented by DraftState, ReviewState, and PublishedState

• Context: Maintains the current state and delegates behavior to it

  • Represented by DocumentContext

2. Key Classes and Their Roles

• DocumentState

  • Common interface for all states
  • Declares the method publish(context: DocumentContext): void

• DraftState

  • Concrete state for the "draft" phase
  • The publish method sends a review request and transitions to ReviewState

• ReviewState

  • Concrete state for the "under review" phase
  • The publish method publishes the document and transitions to PublishedState

• PublishedState

  • Concrete state for the "published" phase
  • The publish method outputs a message indicating that the document is already published

• DocumentContext

  • The context class that maintains the current state
  • Calls the state's publish method and manages transitions using setState

3. UML Class Diagram

4. Benefits of the State Pattern

• Eliminates Conditional Branching: Each state's logic is encapsulated in a separate class
• Extensibility: New states can be added by implementing DocumentState
• Runtime Flexibility: The state can be changed dynamically during execution

This design clearly separates behavior by state and allows safe, manageable state transitions.
It is especially effective when multiple states exist and each has distinct behavior.