What is the Strategy pattern?

Detailed explanation

The Strategy pattern is a behavioral design pattern that defines a family of algorithms, encapsulates each one behind a common interface, and makes them interchangeable. Instead of embedding every variation inside one class, the application delegates a particular operation to a strategy object. It is useful when the same task has several implementations, such as calculating discounts, choosing shipping charges, or applying sorting rules. The algorithm can be selected at runtime without changing the code that invokes it through the interface.

In the discount example, DiscountStrategy is the strategy interface, and its apply(double price) method defines the contract. BlackFridayDiscount is a concrete strategy that returns half the supplied price. A checkout service can act as the context: it stores a DiscountStrategy reference, receives the implementation through its constructor, and calls strategy.apply(price). With BlackFridayDiscount selected, applying the strategy to 100.0 produces 50.0. Under the hood, Java uses dynamic method dispatch to invoke the implementation belonging to the actual strategy object, even though the reference is declared using the interface type.

This separates the checkout workflow from discount calculations and uses composition rather than making subclasses of the checkout service for every discount type. Adding a FestivalDiscount usually requires a new implementation and a change wherever strategies are configured or selected, not a change to the checkout calculation itself. This supports the Open/Closed Principle, but it does not eliminate selection logic: a factory, configuration layer, or caller still chooses the strategy. Runtime selection also does not require a setter; constructor injection can select a strategy when the context is created.

Interviewers typically expect you to identify the interface, concrete strategies, and context, then explain the trade-off. Strategies make algorithms independently testable and reduce repeated conditional logic, but introduce extra abstractions and may be unnecessary for a tiny, stable calculation. In Java, a single-abstract-method strategy interface can also be implemented with a lambda. For production monetary calculations, prefer BigDecimal with an explicit rounding policy rather than the example's double, and ensure every strategy respects the same input and output contract.

Key points to remember

• Strategy encapsulates interchangeable algorithms behind a shared interface.
• The context delegates algorithm-specific work to an injected strategy object.
• Java's dynamic method dispatch invokes the selected implementation.
• New strategies can extend behaviour without modifying the context's algorithm invocation.
• Selection logic remains somewhere; strategies organise variation rather than eliminate it.

Common mistakes candidates make

• Claiming that Strategy removes all conditionals or requires a runtime setter.
• Putting every algorithm inside the context while leaving the strategy implementations as empty wrappers.
• Confusing Strategy with State: Strategy represents alternative algorithms, while State represents behaviour associated with an object's current state.

Likely follow-up questions