1. Definition

The Strategy Design Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from the clients that use it.

2. Problem Statement

When you have multiple ways to perform an operation and want to switch between them dynamically, hardcoding every variant of the algorithm makes the code difficult to maintain, extend, and scale.

3. Solution

Encapsulate each algorithm (or strategy) into separate classes with a common interface. This makes it easy to interchange algorithms, extend the system with new algorithms, and isolate the algorithm logic from the main application logic.

4. Real-World Use Cases

1. Different compression algorithms (ZIP, RAR, TAR) for a file archiving application.

2. Various payment methods (Credit Card, PayPal, Stripe) for an e-commerce website.

3. Different AI behaviors in a video game.

5. Implementation Steps

1. Define a strategy interface common to all supported algorithms.

2. Implement concrete strategy classes for each algorithm.

3. Create a context class that uses a strategy object to perform an operation.

6. Implementation in Ruby

# Step 1: Strategy Interface class Strategy def execute raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'" end end # Step 2: Concrete Strategies class AddStrategy < Strategy def execute(a, b) a + b end end class SubtractStrategy < Strategy def execute(a, b) a - b end end # Step 3: Context Class class Context attr_accessor :strategy def initialize(strategy) @strategy = strategy end def execute_strategy(a, b) @strategy.execute(a, b) end end # Client Code context = Context.new(AddStrategy.new) puts context.execute_strategy(5, 3) # Outputs 8 context.strategy = SubtractStrategy.new puts context.execute_strategy(5, 3) # Outputs 2 

Output:

8 2 

Explanation:

1. Strategy is an abstract class that defines an interface for all concrete strategies.

2. AddStrategy and SubtractStrategy are concrete strategies that implement specific algorithms.

3. Context is a class that uses a strategy object to perform an operation. The strategy object can be changed at runtime to execute different algorithms.

4. In the client code, we first use the AddStrategy to add two numbers, and then we change the strategy to SubtractStrategy to subtract the numbers.

7. When to use?

Use the Strategy Pattern when:

1. You need to choose an algorithm from a family of algorithms dynamically at runtime.

2. You have multiple ways of doing something, and you want to switch between them easily.

3. You want to isolate the algorithm logic from the main application logic.

4. You want to make a class unaware of the specific algorithms it uses.