How can you use the strategy pattern to encapsulate algorithms in software design?

1 Benefits of the strategy pattern

The strategy pattern offers several advantages for software design, such as adhering to the open/closed principle. This means that software entities should be open for extension but closed for modification, and using the strategy pattern allows you to add new algorithms without changing existing ones or the context that uses them. Additionally, it reduces code duplication and complexity, as the same algorithm can be reused for different contexts or scenarios. Moreover, it enhances testability and maintainability, as each algorithm can be isolated and tested independently, and easily replaced or updated without affecting the rest of the code.

2 Components of the strategy pattern

The strategy pattern consists of three main components: the context, the strategy, and the concrete strategies. The context is a class that uses an algorithm to perform some operation and maintains a reference to a strategy object, which can be set or changed at runtime. The strategy is an interface or an abstract class that defines the common behavior for all algorithms; it declares a method that the context can invoke to execute the algorithm. The concrete strategies are classes that implement the strategy interface or inherit from the abstract class, providing the specific implementation of the algorithm.

3 Example of the strategy pattern

To illustrate how to use the strategy pattern, let's consider a simple example of a calculator application that can perform different operations on two numbers. The operations are the algorithms that we want to encapsulate and make interchangeable.

First, we define the strategy interface, which declares a method called execute that takes two numbers as parameters and returns a number.

public interface OperationStrategy {
  public double execute(double x, double y);
}        

Next, we implement the concrete strategies, which are classes that implement the operation strategy interface and provide the specific logic for each operation. For example, we can have a class for addition, subtraction, multiplication, and division.

public class AdditionStrategy implements OperationStrategy {
  public double execute(double x, double y) {
    return x + y;
  }
}
public class SubtractionStrategy implements OperationStrategy {
  public double execute(double x, double y) {
    return x - y;
  }
}
public class MultiplicationStrategy implements OperationStrategy {
  public double execute(double x, double y) {
    return x * y;
  }
}
public class DivisionStrategy implements OperationStrategy {
  public double execute(double x, double y) {
    return x / y;
  }
}        

Then, we define the context class, which is the calculator that uses an operation strategy to perform an operation on two numbers. It has a field to store the current strategy, a constructor to initialize it, and a method to set it. It also has a method to perform the operation, which invokes the execute method of the strategy object.

public class Calculator {
  private OperationStrategy strategy;
  public Calculator(OperationStrategy strategy) {
    this.strategy = strategy;
  }
  public void setStrategy(OperationStrategy strategy) {
    this.strategy = strategy;
  }
  public double performOperation(double x, double y) {
    return strategy.execute(x, y);
  }
}        

Finally, we can use the calculator class and change its strategy at runtime, depending on the user's input or preference. For example, we can create a calculator object with an initial strategy of addition, and then change it to subtraction, multiplication, or division as needed.

public class CalculatorDemo {
  public static void main(String[] args) {
    Calculator calculator = new Calculator(new AdditionStrategy());
    System.out.println(calculator.performOperation(10, 5)); // prints 15
    calculator.setStrategy(new SubtractionStrategy());
    System.out.println(calculator.performOperation(10, 5)); // prints 5
    calculator.setStrategy(new MultiplicationStrategy());
    System.out.println(calculator.performOperation(10, 5)); // prints 50
    calculator.setStrategy(new DivisionStrategy());
    System.out.println(calculator.performOperation(10, 5)); // prints 2
  }
}        

4 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?