Design Patterns in Java

public enum ConfigManager {
    INSTANCE;

    private final Map<String, String> settings = new HashMap<>();

    public String get(String key) { return settings.get(key); }
}

// Usage
ConfigManager.INSTANCE.get("apiUrl");

Common follow-ups: Why is the enum-based Singleton considered immune to reflection-based attacks that can break the classic private-constructor approach?;What are the criticisms of Singleton as an anti-pattern, particularly regarding testability?

public class Pizza {
    private final String size;
    private final boolean cheese, pepperoni, mushroom;

    private Pizza(Builder b) {
        size = b.size; cheese = b.cheese; pepperoni = b.pepperoni; mushroom = b.mushroom;
    }

    public static class Builder {
        private final String size;
        private boolean cheese, pepperoni, mushroom;
        public Builder(String size) { this.size = size; }
        public Builder cheese(boolean val) { cheese = val; return this; }
        public Builder pepperoni(boolean val) { pepperoni = val; return this; }
        public Pizza build() { return new Pizza(this); }
    }
}

Pizza pizza = new Pizza.Builder("large").cheese(true).pepperoni(true).build();

Common follow-ups: How does Java's newer Record type relate to or compete with the Builder pattern for simpler cases?;What's the difference between this classic Builder pattern and Lombok's @Builder-generated equivalent?

public interface Observer { void update(String event); }

public class EventPublisher {
    private final List<Observer> observers = new ArrayList<>();
    public void subscribe(Observer o) { observers.add(o); }
    public void publish(String event) {
        for (Observer o : observers) { o.update(event); }
    }
}

EventPublisher publisher = new EventPublisher();
publisher.subscribe(event -> System.out.println("Received: " + event));
publisher.publish("orderPlaced");

Common follow-ups: What are the memory leak risks of the Observer pattern if subscribers forget to unsubscribe (a 'lapsed listener' problem)?;How does the Observer pattern relate conceptually to the publish-subscribe messaging pattern used in distributed systems?

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);

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?

InputStream raw = new FileInputStream("data.gz");
InputStream buffered = new BufferedInputStream(raw);      // adds buffering
InputStream decompressed = new GZIPInputStream(buffered);  // adds decompression

// Each layer implements InputStream and delegates to the wrapped stream,
// composing behaviors without needing a single "BufferedGZIPFileInputStream" class

Common follow-ups: Why does this pattern avoid the 'class explosion' problem that inheritance-based combination of behaviors would create?;How does Decorator differ structurally from the Proxy pattern, given both wrap an object behind the same interface?

// GoF Factory Method pattern: subclasses decide the concrete type
abstract class DocumentCreator {
    abstract Document createDocument();  // subclasses override to return different Document types
}
class PdfCreator extends DocumentCreator {
    Document createDocument() { return new PdfDocument(); }
}

// Static factory method idiom: just a descriptively-named static creation method
public class Point {
    public static Point of(int x, int y) { return new Point(x, y); }  // more readable than 'new Point(x, y)'
}

Common follow-ups: What are the specific benefits static factory methods have over public constructors, according to Effective Java?;When would you actually need the full GoF Factory Method pattern versus just a simpler static factory method?

public interface PaymentGateway { boolean charge(double amount); }

public class OrderService {
    private final PaymentGateway gateway;
    public OrderService(PaymentGateway gateway) {  // dependency injected via constructor
        this.gateway = gateway;
    }
    public boolean placeOrder(double total) { return gateway.charge(total); }
}

// In tests, trivially substitute a fake implementation, no framework needed
OrderService testService = new OrderService(amount -> true);  // lambda implementing PaymentGateway

Common follow-ups: What's the difference between constructor injection, setter injection, and field injection, and why is constructor injection generally preferred?;At what codebase size/complexity does manual DI wiring typically become unwieldy enough to justify adopting a framework like Spring?

// Third-party class with an incompatible interface you can't modify
class LegacyRectangle {
    void oldDraw(int x1, int y1, int x2, int y2) { /* ... */ }
}

// Your application's expected interface
interface Shape { void draw(); }

// Adapter bridges the two
class RectangleAdapter implements Shape {
    private final LegacyRectangle legacy;
    private final int x, y, width, height;
    public RectangleAdapter(LegacyRectangle legacy, int x, int y, int w, int h) {
        this.legacy = legacy; this.x = x; this.y = y; this.width = w; this.height = h;
    }
    public void draw() { legacy.oldDraw(x, y, x + width, y + height); }
}

Common follow-ups: How does the Adapter pattern differ from the Facade pattern, given both seem to 'wrap' existing functionality?;What's the difference between a class adapter (using inheritance) and an object adapter (using composition) approach?

// Modern alternative using sealed interfaces and pattern matching (Java 21+)
sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
record Triangle(double base, double height) implements Shape {}

double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> 0.5 * t.base() * t.height();
        // compiler ERRORS if a new Shape subtype is added and this switch isn't updated -- exhaustiveness checking
    };
}

Common follow-ups: What specific scenario still favors the classic double-dispatch Visitor pattern over sealed classes and pattern matching?;How does sealed class exhaustiveness checking actually work at compile time?

public abstract class DataProcessor {
    public final void process() {  // template method -- final, defines fixed algorithm structure
        loadData();
        validate();
        transform();
        saveResults();
    }
    protected abstract void loadData();
    protected abstract void transform();
    protected void validate() { /* default implementation, can be overridden */ }
    protected void saveResults() { System.out.println("Saving..."); }
}

class CsvProcessor extends DataProcessor {
    protected void loadData() { /* CSV-specific loading */ }
    protected void transform() { /* CSV-specific transformation */ }
}

Common follow-ups: How does Template Method differ from the Strategy pattern, given both involve customizable behavior?;Why is marking the template method itself as final considered important to preserving the pattern's intent?