State Pattern vs Strategy Pattern

state_vs_strategy.py

"""
Comparison of State and Strategy Patterns in Python

This script demonstrates the similarities and differences between the State and Strategy patterns.
Each pattern is implemented separately with an execution example.

### Similarities:
1. **Encapsulation of Behavior** – Both patterns encapsulate behaviors in separate classes, promoting the **Single Responsibility Principle (SRP)**.
2. **Dynamic Behavior Switching** – Both allow switching between different behaviors (strategies or states) at runtime.
3. **Use of Composition Over Inheritance** – Instead of using conditionals (`if-else` or `switch` statements), they promote using composition to delegate behavior.

### Differences:
| Feature         | **State Pattern** | **Strategy Pattern** |
|---------------|----------------|----------------|
| **Purpose** | Manages an object's behavior depending on its state. The object transitions between states, and each state defines specific behavior. | Encapsulates interchangeable algorithms or behaviors that can be selected dynamically. |
| **Context Awareness** | Each state is aware of the context and can change the state of the object. | Strategies are typically unaware of the context; they just execute an algorithm. |
| **Change Trigger** | Changes happen based on conditions within the state itself. | The client explicitly selects a strategy. |
| **Typical Use Case** | Used when an object behaves differently depending on its internal state. | Used when multiple algorithms need to be swapped dynamically without modifying the client code. |

### Conclusion:
While both patterns encapsulate behavior and allow switching, **State is about dynamic object behavior changes based on internal conditions**, whereas **Strategy is about selecting interchangeable algorithms without modifying the client code**. They are about **70% similar in structure** but **serve different intents**.
"""
from abc import ABC, abstractmethod

class State(ABC):
    """Abstract state class defining the interface for states."""
    @abstractmethod
    def handle(self, context) -> None:
        pass

class ConcreteStateA(State):
    """Concrete State A - transitions to State B."""
    def handle(self, context) -> None:
        print("State A: Switching to State B")
        context.state = ConcreteStateB()

class ConcreteStateB(State):
    """Concrete State B - transitions to State A."""
    def handle(self, context) -> None:
        print("State B: Switching to State A")
        context.state = ConcreteStateA()

class Context:
    """Context that maintains a reference to a State object."""
    def __init__(self, state: State) -> None:
        self.state = state

    def request(self) -> None:
        """Triggers the current state's behavior and possibly changes state."""
        self.state.handle(self)

class Strategy(ABC):
    """Abstract strategy class defining the interface for strategies."""
    @abstractmethod
    def execute(self) -> None:
        pass

class ConcreteStrategyA(Strategy):
    """Concrete Strategy A."""
    def execute(self) -> None:
        print("Executing Strategy A")

class ConcreteStrategyB(Strategy):
    """Concrete Strategy B."""
    def execute(self) -> None:
        print("Executing Strategy B")

class StrategyContext:
    """Context that uses a strategy."""
    def __init__(self, strategy: Strategy) -> None:
        self.strategy = strategy

    def set_strategy(self, strategy: Strategy) -> None:
        """Allows changing the strategy dynamically."""
        self.strategy = strategy

    def execute_strategy(self) -> None:
        """Executes the current strategy."""
        self.strategy.execute()

if __name__ == "__main__":
    print("--- State Pattern Example ---")
    state_context = Context(ConcreteStateA())
    state_context.request()  # State A -> B
    state_context.request()  # State B -> A
    
    print("\n--- Strategy Pattern Example ---")
    strategy_context = StrategyContext(ConcreteStrategyA())
    strategy_context.execute_strategy()  # Strategy A
    strategy_context.set_strategy(ConcreteStrategyB())
    strategy_context.execute_strategy()  # Strategy B