Design patterns you'll actually use

// Strategy: interchangeable algorithms behind one interface, chosen at runtime.
interface ShippingCost { readonly name: string; cost(weightKg: number): number; }
class Standard implements ShippingCost { readonly name = "Standard"; cost(w: number): number { return 5 + w; } }
class Express implements ShippingCost { readonly name = "Express"; cost(w: number): number { return 15 + 2 * w; } }

// Observer: the order announces events; listeners subscribe without the order knowing them.
class EventBus {
  private listeners = new Map<string, ((payload: string) => void)[]>();
  subscribe(event: string, fn: (payload: string) => void): void {
    this.listeners.set(event, [...(this.listeners.get(event) ?? []), fn]);
  }
  publish(event: string, payload: string): void {
    for (const fn of this.listeners.get(event) ?? []) fn(payload);
  }
}

// Factory: callers ask for "email" or "sms" and never name a concrete class.
interface Notifier { send(msg: string): string; }
class EmailNotifier implements Notifier { send(msg: string): string { return `email: ${msg}`; } }
class SmsNotifier implements Notifier { send(msg: string): string { return `sms: ${msg}`; } }
function makeNotifier(kind: string): Notifier {
  const makers: Record<string, () => Notifier> = { email: () => new EmailNotifier(), sms: () => new SmsNotifier() };
  const make = makers[kind];
  if (!make) throw new Error(`unknown notifier ${kind}`);
  return make();
}

// Decorator: wrap an object in another with the same interface to add behaviour.
interface PaymentGateway { charge(amount: number): string; }
class FakeGateway implements PaymentGateway { charge(amount: number): string { return `charged ${amount}`; } }
class LoggingGateway implements PaymentGateway {
  constructor(private inner: PaymentGateway, private log: string[]) {}
  charge(amount: number): string {
    this.log.push(`about to charge ${amount}`);
    const result = this.inner.charge(amount);
    this.log.push(`result: ${result}`);
    return result;
  }
}

for (const s of [new Standard(), new Express()]) console.log(`${s.name} shipping for 3 kg: ${s.cost(3)}`);
const bus = new EventBus();
bus.subscribe("order_paid", (o) => console.log(makeNotifier("email").send(`order ${o} paid`)));
bus.subscribe("order_paid", (o) => console.log(makeNotifier("sms").send(`order ${o} paid`)));
const log: string[] = [];
const gateway = new LoggingGateway(new FakeGateway(), log);
console.log(gateway.charge(42));
bus.publish("order_paid", "#7");
console.log("log:", log.join(" | "));

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Supplier;

// Strategy: interchangeable algorithms behind one interface, chosen at runtime.
interface ShippingCost {
    int cost(int weightKg);
}

class Standard implements ShippingCost {
    public int cost(int w) { return 5 + w; }
}

class Express implements ShippingCost {
    public int cost(int w) { return 15 + 2 * w; }
}

// Observer: the order announces events; listeners subscribe without the order knowing them.
class EventBus {
    private final Map<String, List<Consumer<String>>> listeners = new HashMap<>();

    void subscribe(String event, Consumer<String> fn) {
        listeners.computeIfAbsent(event, e -> new ArrayList<>()).add(fn);
    }

    void publish(String event, String payload) {
        listeners.getOrDefault(event, List.of()).forEach(fn -> fn.accept(payload));
    }
}

// Factory: callers ask for "email" or "sms" and never name a concrete class.
interface Notifier {
    String send(String msg);
}

class EmailNotifier implements Notifier {
    public String send(String msg) { return "email: " + msg; }
}

class SmsNotifier implements Notifier {
    public String send(String msg) { return "sms: " + msg; }
}

class Notifiers {
    private static final Map<String, Supplier<Notifier>> MAKERS = Map.of("email", EmailNotifier::new, "sms", SmsNotifier::new);

    static Notifier make(String kind) {
        Supplier<Notifier> m = MAKERS.get(kind);
        if (m == null) throw new IllegalArgumentException("unknown notifier " + kind);
        return m.get();
    }
}

// Decorator: wrap an object in another with the same interface to add behaviour.
interface PaymentGateway {
    String charge(int amount);
}

class FakeGateway implements PaymentGateway {
    public String charge(int amount) { return "charged " + amount; }
}

class LoggingGateway implements PaymentGateway {
    private final PaymentGateway inner;
    private final List<String> log;

    LoggingGateway(PaymentGateway inner, List<String> log) {
        this.inner = inner;
        this.log = log;
    }

    public String charge(int amount) {
        log.add("about to charge " + amount);
        String result = inner.charge(amount);
        log.add("result: " + result);
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        for (ShippingCost s : List.of(new Standard(), new Express()))
            System.out.println(s.getClass().getSimpleName() + " shipping for 3 kg: " + s.cost(3));
        EventBus bus = new EventBus();
        bus.subscribe("order_paid", o -> System.out.println(Notifiers.make("email").send("order " + o + " paid")));
        bus.subscribe("order_paid", o -> System.out.println(Notifiers.make("sms").send("order " + o + " paid")));
        List<String> log = new ArrayList<>();
        PaymentGateway gateway = new LoggingGateway(new FakeGateway(), log);
        System.out.println(gateway.charge(42));
        bus.publish("order_paid", "#7");
        System.out.println("log: " + String.join(" | ", log));
    }
}