Design Patterns in Java — Complete Notes

public class Broken {
    private static Broken instance;
    private Broken() { }                       // private ctor: nobody else can `new` it

    public static Broken getInstance() {
        if (instance == null) {                // check-then-act — a RACE CONDITION
            instance = new Broken();           // two threads can BOTH pass the check
        }
        return instance;
    }
}
// Thread A checks -> null. Thread B checks -> null. Both construct. Two singletons.

public static synchronized Broken getInstance() {
    if (instance == null) instance = new Broken();
    return instance;
}
// Correct. But EVERY call locks — including the millions of calls after
// initialisation, where there's nothing left to synchronise. Pure waste.

public class DCL {
    private static volatile DCL instance;      // the `volatile` is NOT optional
    private DCL() { }

    public static DCL getInstance() {
        if (instance == null) {                // 1st check — no lock, the fast path
            synchronized (DCL.class) {
                if (instance == null) {        // 2nd check — someone may have won the race
                    instance = new DCL();
                }
            }
        }
        return instance;
    }
}

public class Holder {
    private Holder() { }

    private static class Lazy {                 // a nested class isn't loaded until first USED
        static final Holder INSTANCE = new Holder();
    }

    public static Holder getInstance() {
        return Lazy.INSTANCE;                   // triggers Lazy's initialisation, right here
    }
}
// The JVM ALREADY guarantees class initialisation is thread-safe and happens exactly once.
// So we get laziness and thread safety for free, with zero synchronisation on any call.
// No volatile, no locks, no cleverness. Just leaning on the classloader's own guarantees.

public enum Config {
    INSTANCE;

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

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

// Use:
Config.INSTANCE.get("db.url");

interface Notification { void send(String msg); }

class EmailNotification implements Notification {
    public void send(String msg) { System.out.println("Email: " + msg); }
}
class SmsNotification implements Notification {
    public void send(String msg) { System.out.println("SMS: " + msg); }
}
class PushNotification implements Notification {
    public void send(String msg) { System.out.println("Push: " + msg); }
}

class NotificationFactory {
    static Notification create(String type) {
        return switch (type) {
            case "email" -> new EmailNotification();
            case "sms"   -> new SmsNotification();
            case "push"  -> new PushNotification();
            default -> throw new IllegalArgumentException("unknown type: " + type);
        };
    }
}

// Caller doesn't know or care which class it gets:
Notification n = NotificationFactory.create(config.getType());
n.send("hello");

abstract class Dialog {

    protected abstract Button createButton();   // THE factory method — subclasses answer this

    public void render() {                      // the algorithm lives here, and doesn't change
        Button b = createButton();
        b.onClick(this::close);
        b.render();
    }
    void close() { }
}

class WindowsDialog extends Dialog {
    protected Button createButton() { return new WindowsButton(); }
}
class WebDialog extends Dialog {
    protected Button createButton() { return new HtmlButton(); }
}

// render() is written ONCE and works for every platform.
// The subclass supplies only the one varying decision.

// When products must MATCH each other — you must never mix Windows and Mac widgets
interface GuiFactory {
    Button   createButton();
    Checkbox createCheckbox();
}

class WindowsFactory implements GuiFactory {
    public Button   createButton()   { return new WindowsButton(); }
    public Checkbox createCheckbox() { return new WindowsCheckbox(); }
}
class MacFactory implements GuiFactory {
    public Button   createButton()   { return new MacButton(); }
    public Checkbox createCheckbox() { return new MacCheckbox(); }
}

// Choose the family ONCE; every product is guaranteed consistent thereafter.
GuiFactory f = isWindows ? new WindowsFactory() : new MacFactory();
Button b = f.createButton();
Checkbox c = f.createCheckbox();     // cannot accidentally be a MacCheckbox

// Telescoping constructors: the classic disease
public Pizza(int size) { ... }
public Pizza(int size, boolean cheese) { ... }
public Pizza(int size, boolean cheese, boolean pepperoni) { ... }
public Pizza(int size, boolean cheese, boolean pepperoni, boolean bacon) { ... }

new Pizza(12, true, false, true);
//            ^^^^  ^^^^^  ^^^^  which one is bacon again?

// And this compiles perfectly, silently doing the wrong thing:
new Pizza(12, false, true, true);   // meant cheese, got pepperoni. No warning. Ever.

public class Pizza {
    private final int size;                 // all final -> immutable & thread-safe
    private final boolean cheese;
    private final boolean pepperoni;
    private final boolean bacon;

    private Pizza(Builder b) {              // private ctor: the Builder is the ONLY way in
        this.size      = b.size;
        this.cheese    = b.cheese;
        this.pepperoni = b.pepperoni;
        this.bacon     = b.bacon;
    }

    public static Builder builder(int size) { return new Builder(size); }

    public static class Builder {
        private final int size;             // required -> in the Builder's constructor
        private boolean cheese;             // optional -> sensible defaults
        private boolean pepperoni;
        private boolean bacon;

        public Builder(int size) { this.size = size; }

        public Builder cheese()    { this.cheese = true; return this; }     // return this -> chain
        public Builder pepperoni() { this.pepperoni = true; return this; }
        public Builder bacon()     { this.bacon = true; return this; }

        public Pizza build() {
            if (size < 6) throw new IllegalArgumentException("size must be >= 6");  // validate HERE
            return new Pizza(this);         // the object is never seen in a partial state
        }
    }
}

// Now read this and tell me it's ambiguous:
Pizza p = Pizza.builder(12)
    .cheese()
    .bacon()
    .build();

// For 2-3 fields a record is simply better. Don't reach for a Builder reflexively.
record Point(int x, int y) { }

// The Builder earns its keep once there are many optional fields —
// and records pair with it nicely for the validation:
record Pizza(int size, boolean cheese, boolean pepperoni, boolean bacon) {
    Pizza {
        if (size < 6) throw new IllegalArgumentException("size must be >= 6");
    }
    static Builder builder(int size) { return new Builder(size); }
    // ... Builder as above, calling the canonical constructor in build()
}

class Checkout {
    double pay(double amount, String method) {
        if (method.equals("card")) {
            // 20 lines of card logic
        } else if (method.equals("paypal")) {
            // 20 lines of PayPal logic
        } else if (method.equals("crypto")) {
            // 20 lines of crypto logic
        }
        // Adding "applepay" means EDITING this class. Again.
        // It violates Open/Closed: you can't extend it without modifying it.
        // And it's untestable in isolation, and 300 lines long.
    }
}

interface PaymentStrategy {              // the strategy interface
    void pay(double amount);
}

class CardPayment implements PaymentStrategy {
    private final String cardNumber;
    CardPayment(String cardNumber) { this.cardNumber = cardNumber; }
    public void pay(double amount) { System.out.println("Card: " + amount); }
}
class PayPalPayment implements PaymentStrategy {
    public void pay(double amount) { System.out.println("PayPal: " + amount); }
}

class Checkout {                          // the CONTEXT — knows the interface, not the classes
    private PaymentStrategy strategy;
    void setStrategy(PaymentStrategy s) { this.strategy = s; }
    void checkout(double amount) { strategy.pay(amount); }   // just delegate
}

Checkout c = new Checkout();
c.setStrategy(new CardPayment("4111..."));
c.checkout(99.99);
c.setStrategy(new PayPalPayment());       // swapped at RUNTIME
c.checkout(50.00);

// Adding ApplePay = adding ONE new class. Checkout is never touched. That's Open/Closed.

// PaymentStrategy has ONE abstract method -> it's a functional interface -> lambda territory
Checkout c = new Checkout();
c.setStrategy(amount -> System.out.println("Card: " + amount));
c.setStrategy(amount -> System.out.println("PayPal: " + amount));

// Often you don't even need your own interface:
Comparator<Person> byName = Comparator.comparing(Person::getName);   // a sorting strategy
list.sort(byName);                                                   // ...injected here

// A registry of strategies, no switch anywhere:
Map<String, PaymentStrategy> strategies = Map.of(
    "card",   amount -> chargeCard(amount),
    "paypal", amount -> chargePayPal(amount)
);
strategies.get(method).pay(amount);

interface Observer {                     // what listeners implement
    void update(String event);
}

class Subject {                          // the thing being watched
    private final List<Observer> observers = new CopyOnWriteArrayList<>();  // safe iteration

    public void subscribe(Observer o)   { observers.add(o); }
    public void unsubscribe(Observer o) { observers.remove(o); }   // ESSENTIAL — see gotchas

    protected void notifyAll(String event) {
        for (Observer o : observers) o.update(event);   // fire away
    }
}

class OrderService extends Subject {
    public void placeOrder(Order order) {
        save(order);
        notifyAll("ORDER_PLACED:" + order.getId());     // I don't know or care who listens
    }
}

// Listeners register themselves
OrderService svc = new OrderService();
svc.subscribe(e -> emailService.sendConfirmation(e));
svc.subscribe(e -> analytics.track(e));
svc.subscribe(e -> inventory.reserve(e));
// Adding an SMS notification = one more subscribe(). OrderService is never modified.

button.addActionListener(e -> save());        // Swing/AWT
element.addEventListener("click", handler);   // the DOM
publisher.subscribe(subscriber);              // Flow API (Java 9) / Reactive Streams
@EventListener void onOrder(OrderEvent e) { } // Spring
// Kafka, RabbitMQ, webhooks — pub/sub is Observer at network scale.

// Coffee, and you want milk, sugar, whipped cream...
class Coffee { }
class CoffeeWithMilk extends Coffee { }
class CoffeeWithSugar extends Coffee { }
class CoffeeWithMilkAndSugar extends Coffee { }
class CoffeeWithMilkAndWhip extends Coffee { }
class CoffeeWithMilkAndSugarAndWhip extends Coffee { }
// ... 3 add-ons -> 8 classes. 10 add-ons -> 1024 classes. It's 2^n. This does not work.

interface Coffee {
    double cost();
    String description();
}

class SimpleCoffee implements Coffee {                    // the CONCRETE COMPONENT
    public double cost() { return 2.00; }
    public String description() { return "coffee"; }
}

abstract class CoffeeDecorator implements Coffee {        // the BASE DECORATOR
    protected final Coffee inner;                         // IS-A Coffee, HAS-A Coffee — the trick
    protected CoffeeDecorator(Coffee inner) { this.inner = inner; }
}

class Milk extends CoffeeDecorator {
    Milk(Coffee inner) { super(inner); }
    public double cost() { return inner.cost() + 0.50; }              // delegate, then ADD
    public String description() { return inner.description() + " + milk"; }
}
class Sugar extends CoffeeDecorator {
    Sugar(Coffee inner) { super(inner); }
    public double cost() { return inner.cost() + 0.20; }
    public String description() { return inner.description() + " + sugar"; }
}

// Compose freely, at runtime, in any order and any depth:
Coffee c = new Sugar(new Milk(new SimpleCoffee()));
System.out.println(c.description());   // coffee + milk + sugar
System.out.println(c.cost());          // 2.70

// 10 add-ons = 10 classes, not 1024. And each one is independently testable.

InputStream in =
    new BufferedInputStream(              // adds buffering
        new GZIPInputStream(              // adds decompression
            new FileInputStream("data.gz")));   // the actual source

// Each wrapper adds ONE capability. Reorder or omit at will —
// this is why java.io looks so verbose, and also why it's so flexible.

// Same idea:
new BufferedReader(new InputStreamReader(System.in));
Collections.unmodifiableList(list);        // a decorator that removes a capability
Collections.synchronizedMap(map);          // a decorator that adds locking