11.5.2. Strategy Pattern

Defines a family of algorithms, encapsulates each one, and makes them interchangeable.

The Strategy Pattern is a behavioral design pattern that allows you to define a set of algorithms, encapsulate each algorithm in a separate class, and make them interchangeable. This means that you can choose which algorithm to use at runtime without changing the code that uses these algorithms. Encapsulation means that the implementation details of each algorithm are hidden from the user, allowing for more flexibility and maintainability.

Imagine a navigation app that can calculate the best route for you. It can use different algorithms to determine the fastest route, the shortest distance, or the most scenic view (such as driving, walking, or cycling). If you want to switch from driving to walking, the app simply uses a different strategy without the user needing to worry about how the routing works internally.

interface Strategy {
    int execute(int a, int b);
}```

In this code snippet, we declare an interface named Strategy. This interface defines a method execute that takes two integer parameters and returns an integer. By defining this method in an interface, we ensure that any class that implements this interface will provide its own version of the execute method. This allows us to treat different algorithms uniformly since they all conform to the Strategy interface.

Think of a strategy as a recipe interface. Each recipe must have a method for preparing the dish. Just like different chefs can make a dish using their style (sautéing, grilling, baking), different classes implement the execute method of the Strategy interface, each applying its unique approach to solving a problem.

class AddStrategy implements Strategy {
    public int execute(int a, int b) {
        return a + b;
    }
}```

The AddStrategy class implements the Strategy interface. It provides its specific implementation of the execute method, which adds two integers. When an instance of AddStrategy is used, it will perform addition. This is an example of a concrete strategy that can be used interchangeably with other strategies.

Continuing with our recipe analogy, AddStrategy can be thought of as a specific recipe for baking a cake where the ingredients are simply added together. Other strategies like subtracting or multiplying would be different recipes but follow the same general process of combining items.

class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public int executeStrategy(int a, int b) {
        return strategy.execute(a, b);
    }
}```

The Context class holds a reference to a Strategy object, which allows it to call the execute method of the strategy at runtime. The Context class doesn't need to know which specific strategy is being used, making it flexible and easy to change the strategy without modifying the Context class itself. The executeStrategy method delegates the execution to the current strategy.

Think of the Context class as a remote control for a DVD player. You just need to press buttons (execute strategy) without knowing how the internal components work (the actual DVD player mechanisms). You can switch DVDs (strategies) without needing to reconfigure the entire setup.

--