Strategy

The Strategy pattern is a behavioral design pattern that turns a set of behaviors into objects and makes them interchangeable inside the original context object. The original object, called context, holds a reference to a strategy object and delegates it executing the behavior. In order to change the way the context performs its work, other objects may replace the currently linked strategy object with another one.

UML Diagram

+-------------------+        +-------------------+
|    Context        |<-------|  ConcreteContext  |
|-------------------|        |-------------------|
| +setStrategy()    |        | +setStrategy()    |
| +executeStrategy()|        | +executeStrategy()|
+-------------------+        +-------------------+
        ^                           ^
        |                           |
+-------------------+        +-------------------+
|    Strategy       |        |  ConcreteStrategy |
|-------------------|        |-------------------|
| +execute()        |        | +execute()        |
+-------------------+        +-------------------+

In this diagram, Context is an interface with methods setStrategy() and executeStrategy(). Strategy is an interface with the method execute(). ConcreteContext and ConcreteStrategy are classes that implement the Context and Strategy interfaces, respectively. The arrows indicate that the ConcreteContext and ConcreteStrategy classes inherit from the Context and Strategy interfaces.

--- Java Example ---

 public interface Strategy {
     void execute();
 }

 public class ConcreteStrategyA implements Strategy {
     @Override
     public void execute() {
         System.out.println("Executing strategy A");
     }
 }

 public class ConcreteStrategyB implements Strategy {
     @Override
     public void execute() {
         System.out.println("Executing strategy B");
     }
 }

 public class Context {
     private Strategy strategy;

     public void setStrategy(Strategy strategy) {
         this.strategy = strategy;
     }

     public void executeStrategy() {
         strategy.execute();
     }
 }

--- Python Example ---

 import dataclasses
 from abc import ABC, abstractmethod


 class Strategy(ABC):
     @abstractmethod
     def execute(self) -> None:
         pass

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


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


 @dataclasses.dataclass
 class Context:
     _strategy: Strategy

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

     def execute_strategy(self) -> None:
         self._strategy.execute()
         # self._strategy.forgot_to_implement()


 if __name__ == "__main__":
     context = Context(ConcreteStrategyA())
     context.execute_strategy()