All 15 Design Patterns in Java questions
More in Design Patterns in Java
What is the Singleton pattern, and how would you implement a thread-safe Singleton in Java? What is the Factory Method pattern's simplest form -- a basic static factory returning different subtype instances based on input -- and why might you prefer it over exposing constructors directly? How does the Builder pattern solve the "telescoping constructor" problem, and how would you implement it for a class with many optional parameters? What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself?
Advertisement
Java › Design Patterns in Java

What is the Strategy pattern, and how do Java 8's functional interfaces and lambdas make implementing it significantly more concise than the traditional interface-plus-implementation-classes approach?

Intermediate

Answer

Strategy defines a family of interchangeable algorithms behind a common interface, letting the algorithm used by a context object be selected/swapped at runtime -- prior to Java 8, each strategy required its own separate implementation class; with functional interfaces and lambdas, a strategy can often be expressed inline as a lambda expression directly at the point of use, eliminating the boilerplate of defining a full named class for what's conceptually just a single behavior/algorithm, dramatically reducing the ceremony traditionally associated with this pattern.
public interface DiscountStrategy {
    double apply(double price);
}

public class ShoppingCart {
    private DiscountStrategy discount;
    public void setDiscount(DiscountStrategy discount) { this.discount = discount; }
    public double checkout(double total) { return discount.apply(total); }
}

ShoppingCart cart = new ShoppingCart();
cart.setDiscount(price -> price * 0.9);  // 10% off, expressed as a lambda instead of a named class
double finalPrice = cart.checkout(100.0);
Real-world example An e-commerce checkout system swaps between different discount calculation strategies (percentage off, flat amount off, buy-one-get-one) by passing different lambda expressions implementing the same DiscountStrategy functional interface, avoiding the need to define and instantiate a separate named class for each individual discount type.

Common follow-ups: What's the trade-off of using an inline lambda versus a named class implementation when the strategy logic becomes more complex?;How does the Strategy pattern differ conceptually from the Template Method pattern?

Functional Interfaces & Method References;Streams & Lambdas
All 15 Design Patterns in Java questions