Java design patterns cheat sheet#

# Save ONE entire Java block as SingletonDemo.java (for section 1).
# Keep the classes top-level; the block already includes a main method.
javac --release 8 SingletonDemo.java
java SingletonDemo

enum AppConfig {
    INSTANCE;
    private final String env = System.getProperty("env", "prod");
    public String env() { return env; }
}

final class LazyHolderConfig {
    private LazyHolderConfig() {}
    private static class Holder {
        static final LazyHolderConfig I = new LazyHolderConfig();
    }
    public static LazyHolderConfig get() { return Holder.I; }
}

final class DclConfig {
    private static volatile DclConfig instance;
    private DclConfig() {}
    public static DclConfig get() {
        DclConfig local = instance;
        if (local == null) {
            synchronized (DclConfig.class) {
                local = instance;
                if (local == null) instance = local = new DclConfig();
            }
        }
        return local;
    }
}

class SingletonDemo {
    public static void main(String[] args) {
        System.out.println(AppConfig.INSTANCE.env());
        System.out.println(LazyHolderConfig.get() == LazyHolderConfig.get()); // true
        System.out.println(DclConfig.get() == DclConfig.get());               // true
    }
}

interface Notifier { void send(String to, String body); }

final class EmailNotifier implements Notifier {
    public void send(String to, String body) {
        System.out.println("email -> " + to + ": " + body);
    }
}
final class SmsNotifier implements Notifier {
    public void send(String to, String body) {
        System.out.println("sms -> " + to + ": " + body);
    }
}

abstract class AlertService {
    abstract Notifier createNotifier();          // factory method
    void alert(String to, String body) {
        createNotifier().send(to, body);
    }
}
final class EmailAlertService extends AlertService {
    Notifier createNotifier() { return new EmailNotifier(); }
}
final class SmsAlertService extends AlertService {
    Notifier createNotifier() { return new SmsNotifier(); }
}

class FactoryMethodDemo {
    public static void main(String[] args) {
        AlertService svc = new SmsAlertService();
        svc.alert("+1555", "disk 90%");
    }
}

interface Connection { String kind(); }
interface Dialect { String limit(int n); }

final class PgConnection implements Connection {
    public String kind() { return "postgres"; }
}
final class PgDialect implements Dialect {
    public String limit(int n) { return " LIMIT " + n; }
}
final class BtConnection implements Connection {
    public String kind() { return "bigtable"; }
}
final class BtDialect implements Dialect {
    public String limit(int n) { return " row-limit=" + n; } // descriptive placeholder
}

interface DbFactory {
    Connection connection();
    Dialect dialect();
}
final class PostgresFactory implements DbFactory {
    public Connection connection() { return new PgConnection(); }
    public Dialect dialect() { return new PgDialect(); }
}
final class BigtableFactory implements DbFactory {
    public Connection connection() { return new BtConnection(); }
    public Dialect dialect() { return new BtDialect(); }
}

final class QueryRunner {
    private final DbFactory factory;
    QueryRunner(DbFactory factory) { this.factory = factory; }
    void run() {
        System.out.println(factory.connection().kind() + factory.dialect().limit(10));
    }
}

class AbstractFactoryDemo {
    public static void main(String[] args) {
        new QueryRunner(new PostgresFactory()).run(); // postgres LIMIT 10
        new QueryRunner(new BigtableFactory()).run(); // bigtable row-limit=10 (description)
    }
}

final class HttpRequest {
    final String method, url, body;
    final int timeoutMs;
    private HttpRequest(Builder b) {
        this.method = b.method;
        this.url = b.url;
        this.body = b.body;
        this.timeoutMs = b.timeoutMs;
    }
    static final class Builder {
        private String method = "GET";
        private String url;
        private String body = "";
        private int timeoutMs = 1000;
        Builder url(String url) { this.url = url; return this; }
        Builder method(String m) { this.method = m; return this; }
        Builder body(String b) { this.body = b; return this; }
        Builder timeoutMs(int t) { this.timeoutMs = t; return this; }
        HttpRequest build() {
            if (url == null || url.trim().isEmpty()) throw new IllegalStateException("url");
            if (method == null || method.trim().isEmpty()) throw new IllegalStateException("method");
            if (body == null) throw new IllegalStateException("body");
            if (timeoutMs <= 0) throw new IllegalStateException("timeout must be positive");
            return new HttpRequest(this);
        }
    }
    public String toString() { return method + " " + url + " t=" + timeoutMs; }
}

class BuilderDemo {
    public static void main(String[] args) {
        HttpRequest r = new HttpRequest.Builder()
                .url("https://example.com")
                .method("POST")
                .body("{\"q\":1}")
                .timeoutMs(250)
                .build();
        System.out.println(r);
    }
}

final class ReportTemplate {
    final String title;
    final java.util.List<String> sections;
    ReportTemplate(String title, java.util.List<String> sections) {
        this.title = title;
        this.sections = new java.util.ArrayList<String>(sections);
    }
    ReportTemplate copy() {                         // prototype
        return new ReportTemplate(title, sections); // new list; immutable Strings shared
    }
}

class PrototypeDemo {
    public static void main(String[] args) {
        ReportTemplate proto = new ReportTemplate("Q3", java.util.Arrays.asList("rev", "cost"));
        ReportTemplate west = proto.copy();
        west.sections.add("west-only");
        System.out.println(proto.sections); // [rev, cost]  — original intact
        System.out.println(west.sections);  // [rev, cost, west-only]
    }
}

final class BufferPool {
    private final java.util.Deque<byte[]> free = new java.util.ArrayDeque<byte[]>();
    private final java.util.Set<byte[]> borrowed = java.util.Collections.newSetFromMap(
            new java.util.IdentityHashMap<byte[], Boolean>());
    BufferPool(int size, int bufBytes) {
        if (size <= 0 || bufBytes <= 0) throw new IllegalArgumentException("positive sizes required");
        for (int i = 0; i < size; i++) free.offer(new byte[bufBytes]);
    }
    synchronized byte[] acquire() {
        byte[] b = free.poll();
        if (b == null) throw new IllegalStateException("pool exhausted"); // bounded, fail-fast policy
        borrowed.add(b);
        return b;
    }
    synchronized void release(byte[] b) {
        if (!borrowed.remove(b)) throw new IllegalArgumentException("foreign or already released buffer");
        java.util.Arrays.fill(b, (byte) 0);
        free.offer(b);
    }
}

class PoolDemo {
    public static void main(String[] args) {
        BufferPool pool = new BufferPool(2, 8);
        byte[] a = pool.acquire();
        try { a[0] = 42; }
        finally { pool.release(a); }
        byte[] b = pool.acquire();
        try { System.out.println(b[0]); } // 0
        finally { pool.release(b); }
    }
}

interface JsonStore { void put(String key, String json); }

final class LegacyXmlStore {
    void saveXml(String id, String xml) {
        System.out.println("xml[" + id + "]=" + xml);
    }
}

final class JsonToXmlAdapter implements JsonStore {
    private final LegacyXmlStore legacy;
    JsonToXmlAdapter(LegacyXmlStore legacy) { this.legacy = legacy; }
    public void put(String key, String json) {
        // Store valid JSON text as XML text content, not a structural JSON-to-XML mapping.
        String escaped = json.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
        legacy.saveXml(key, "<x>" + escaped + "</x>");
    }
}

class AdapterDemo {
    public static void main(String[] args) {
        JsonStore store = new JsonToXmlAdapter(new LegacyXmlStore());
        store.put("u1", "{\"n\":1}");
    }
}

interface Renderer { void draw(String shape); }
final class RasterRenderer implements Renderer {
    public void draw(String shape) { System.out.println("pixels:" + shape); }
}
final class VectorRenderer implements Renderer {
    public void draw(String shape) { System.out.println("paths:" + shape); }
}

abstract class Shape {
    final Renderer renderer;
    Shape(Renderer renderer) { this.renderer = renderer; }
    abstract void draw();
}
final class Circle extends Shape {
    Circle(Renderer r) { super(r); }
    void draw() { renderer.draw("circle"); }
}
final class Square extends Shape {
    Square(Renderer r) { super(r); }
    void draw() { renderer.draw("square"); }
}

class BridgeDemo {
    public static void main(String[] args) {
        new Circle(new VectorRenderer()).draw(); // paths:circle
        new Square(new RasterRenderer()).draw(); // pixels:square
    }
}

interface FileSys {
    int size();
    void print(String indent);
}
final class FileLeaf implements FileSys {
    final String name; final int bytes;
    FileLeaf(String name, int bytes) { this.name = name; this.bytes = bytes; }
    public int size() { return bytes; }
    public void print(String indent) { System.out.println(indent + name + " " + bytes); }
}
final class Folder implements FileSys {
    final String name;
    final java.util.List<FileSys> kids = new java.util.ArrayList<FileSys>();
    Folder(String name) { this.name = name; }
    Folder add(FileSys c) { kids.add(c); return this; }
    public int size() {
        int s = 0;
        for (FileSys c : kids) s += c.size();
        return s;
    }
    public void print(String indent) {
        System.out.println(indent + name + "/");
        for (FileSys c : kids) c.print(indent + "  ");
    }
}

class CompositeDemo {
    public static void main(String[] args) {
        Folder root = new Folder("src")
                .add(new FileLeaf("A.java", 10))
                .add(new Folder("util").add(new FileLeaf("B.java", 5)));
        root.print("");
        System.out.println("total=" + root.size()); // 15
    }
}

interface Coffee { int cost(); String desc(); }
final class Espresso implements Coffee {
    public int cost() { return 2; }
    public String desc() { return "espresso"; }
}
abstract class CoffeeDecorator implements Coffee {
    final Coffee inner;
    CoffeeDecorator(Coffee inner) { this.inner = inner; }
}
final class Milk extends CoffeeDecorator {
    Milk(Coffee c) { super(c); }
    public int cost() { return inner.cost() + 1; }
    public String desc() { return inner.desc() + "+milk"; }
}
final class Whip extends CoffeeDecorator {
    Whip(Coffee c) { super(c); }
    public int cost() { return inner.cost() + 1; }
    public String desc() { return inner.desc() + "+whip"; }
}

class DecoratorDemo {
    public static void main(String[] args) {
        Coffee c = new Whip(new Milk(new Espresso()));
        System.out.println(c.desc() + " $" + c.cost()); // espresso+milk+whip $4
    }
}

final class Inventory { boolean reserve(String sku) { return true; } }
final class Payments { void charge(String user, int cents) { System.out.println("charged " + cents); } }
final class Shipping { void ship(String sku, String user) { System.out.println("ship " + sku + " -> " + user); } }

final class CheckoutFacade {
    private final Inventory inventory = new Inventory();
    private final Payments payments = new Payments();
    private final Shipping shipping = new Shipping();
    void buy(String user, String sku, int cents) {
        if (!inventory.reserve(sku)) throw new IllegalStateException("stock");
        payments.charge(user, cents);
        shipping.ship(sku, user);
    }
}

class FacadeDemo {
    public static void main(String[] args) {
        new CheckoutFacade().buy("u1", "sku-9", 499);
    }
}

final class TreeType {                 // intrinsic, shared
    final String name, texture;
    TreeType(String name, String texture) { this.name = name; this.texture = texture; }
    void draw(int x, int y) { System.out.println(name + "@" + x + "," + y); }
}
final class TreeFactory {
    private static final java.util.concurrent.ConcurrentMap<java.util.List<String>, TreeType> CACHE =
            new java.util.concurrent.ConcurrentHashMap<java.util.List<String>, TreeType>();
    static TreeType type(String name, String texture) {
        java.util.Objects.requireNonNull(name);
        java.util.Objects.requireNonNull(texture);
        // The private key is never mutated or exposed; fields are immutable strings.
        java.util.List<String> key = java.util.Collections.unmodifiableList(java.util.Arrays.asList(name, texture));
        return CACHE.computeIfAbsent(key, k -> new TreeType(name, texture));
    }
}
final class Tree {                     // extrinsic: position
    final int x, y;
    final TreeType type;
    Tree(int x, int y, TreeType type) { this.x = x; this.y = y; this.type = type; }
    void draw() { type.draw(x, y); }
}

class FlyweightDemo {
    public static void main(String[] args) {
        TreeType oak = TreeFactory.type("oak", "oak.png");
        new Tree(1, 2, oak).draw();
        new Tree(3, 4, oak).draw();
        System.out.println(TreeFactory.type("oak", "oak.png") == oak); // true, shared
    }
}

interface Image { void display(); }

final class RealImage implements Image {
    private final String path;
    RealImage(String path) { this.path = path; load(); }
    private void load() { System.out.println("load disk " + path); }
    public void display() { System.out.println("show " + path); }
}

final class LazyImageProxy implements Image {
    private final String path;
    private RealImage real;
    LazyImageProxy(String path) { this.path = path; }
    public void display() {
        if (real == null) real = new RealImage(path); // create on first use
        real.display();
    }
}

class ProxyDemo {
    public static void main(String[] args) {
        Image img = new LazyImageProxy("/big.png");
        System.out.println("constructed, not loaded");
        img.display(); // load + show
        img.display(); // show only
    }
}

abstract class Handler {
    Handler next;
    Handler then(Handler n) { next = n; return n; }
    void handle(int amount) {
        if (amount < 0) throw new IllegalArgumentException("amount must be nonnegative");
        if (canHandle(amount)) doHandle(amount);
        else if (next != null) next.handle(amount);
        else System.out.println("unhandled " + amount);
    }
    abstract boolean canHandle(int amount);
    abstract void doHandle(int amount);
}
final class Manager extends Handler {
    boolean canHandle(int a) { return a <= 1000; }
    void doHandle(int a) { System.out.println("manager ok " + a); }
}
final class Director extends Handler {
    boolean canHandle(int a) { return a <= 10000; }
    void doHandle(int a) { System.out.println("director ok " + a); }
}

class ChainDemo {
    public static void main(String[] args) {
        Handler h = new Manager();
        h.then(new Director());
        h.handle(500);
        h.handle(5000);
        h.handle(50000);
    }
}

interface Command { void execute(); void undo(); }

final class Editor {
    final StringBuilder text = new StringBuilder();
}
final class InsertCmd implements Command {
    private final Editor editor;
    private final String chunk;
    private int start;
    private boolean applied;
    InsertCmd(Editor e, String chunk) {
        this.editor = java.util.Objects.requireNonNull(e);
        this.chunk = java.util.Objects.requireNonNull(chunk);
    }
    public void execute() {
        if (applied) throw new IllegalStateException("already applied");
        start = editor.text.length();
        editor.text.append(chunk);
        applied = true;
    }
    public void undo() {
        // Single-threaded LIFO history; edits must go through that history.
        if (!applied || editor.text.length() != start + chunk.length()
                || !editor.text.substring(start).equals(chunk))
            throw new IllegalStateException("not the current edit");
        editor.text.delete(start, editor.text.length());
        applied = false;
    }
}

final class Invoker {
    private final java.util.Deque<Command> history = new java.util.ArrayDeque<Command>();
    void run(Command c) { c.execute(); history.push(c); }
    void undo() {
        if (!history.isEmpty()) {
            history.peek().undo(); // keep the entry if undo fails
            history.pop();
        }
    }
}

class CommandDemo {
    public static void main(String[] args) {
        Editor ed = new Editor();
        Invoker inv = new Invoker();
        inv.run(new InsertCmd(ed, "Hello"));
        inv.run(new InsertCmd(ed, "!"));
        System.out.println(ed.text); // Hello!
        inv.undo();
        System.out.println(ed.text); // Hello
    }
}

interface Expr { int eval(); }
final class Num implements Expr {
    final int v;
    Num(int v) { this.v = v; }
    public int eval() { return v; }
}
final class Add implements Expr {
    final Expr l, r;
    Add(Expr l, Expr r) { this.l = l; this.r = r; }
    public int eval() { return l.eval() + r.eval(); }
}
final class Mul implements Expr {
    final Expr l, r;
    Mul(Expr l, Expr r) { this.l = l; this.r = r; }
    public int eval() { return l.eval() * r.eval(); }
}

class InterpreterDemo {
    public static void main(String[] args) {
        Expr e = new Add(new Num(2), new Mul(new Num(3), new Num(4))); // 2+3*4
        System.out.println(e.eval()); // 14
    }
}

final class Range implements Iterable<Integer> {
    private final int start, end; // [start, end)
    Range(int start, int end) { this.start = start; this.end = end; }
    public java.util.Iterator<Integer> iterator() {
        return new java.util.Iterator<Integer>() {
            int cur = start;
            public boolean hasNext() { return cur < end; }
            public Integer next() {
                if (!hasNext()) throw new java.util.NoSuchElementException();
                return cur++;
            }
            public void remove() { throw new UnsupportedOperationException(); }
        };
    }
}

class IteratorDemo {
    public static void main(String[] args) {
        for (int x : new Range(3, 6)) System.out.print(x + " "); // 3 4 5
    }
}

interface ChatMediator { void send(User from, String msg); void join(User u); }
final class User {
    final String name;
    final ChatMediator room;
    User(String name, ChatMediator room) { this.name = name; this.room = room; room.join(this); }
    void say(String msg) { room.send(this, msg); }
    void recv(User from, String msg) {
        if (from != this) System.out.println(name + " heard " + from.name + ": " + msg);
    }
}
final class ChatRoom implements ChatMediator {
    private final java.util.List<User> users = new java.util.ArrayList<User>();
    public void join(User u) { users.add(u); }
    public void send(User from, String msg) {
        for (User u : users) u.recv(from, msg);
    }
}

class MediatorDemo {
    public static void main(String[] args) {
        ChatRoom room = new ChatRoom();
        User a = new User("Ann", room), b = new User("Bob", room);
        a.say("hi");
    }
}

final class Doc {
    static final class Memento {
        private final String text;
        private Memento(String text) { this.text = text; }
    }
    private String text = "";
    void type(String s) { text += s; }
    Memento save() { return new Memento(text); }
    void restore(Memento m) { text = java.util.Objects.requireNonNull(m).text; }
    public String toString() { return text; }
}

class MementoDemo {
    public static void main(String[] args) {
        Doc d = new Doc();
        d.type("Hello");
        Doc.Memento snap = d.save();
        d.type(" World");
        System.out.println(d); // Hello World
        d.restore(snap);
        System.out.println(d); // Hello
    }
}

interface Observer { void onEvent(String e); }
final class EventBus {
    private final java.util.List<Observer> obs = new java.util.ArrayList<Observer>();
    void subscribe(Observer o) { obs.add(java.util.Objects.requireNonNull(o)); }
    void unsubscribe(Observer o) { obs.remove(o); }
    void publish(String e) {
        // Single-threaded snapshot: callbacks may unsubscribe without invalidating this loop.
        for (Observer o : new java.util.ArrayList<Observer>(obs)) o.onEvent(e);
    }
}

class ObserverDemo {
    public static void main(String[] args) {
        EventBus bus = new EventBus();
        bus.subscribe(new Observer() {
            public void onEvent(String e) { System.out.println("audit " + e); }
        });
        bus.subscribe(new Observer() {
            public void onEvent(String e) { System.out.println("metrics " + e); }
        });
        bus.publish("login");
    }
}

interface OrderState {
    OrderState pay();
    OrderState ship();
    String name();
}
final class Created implements OrderState {
    public OrderState pay() { return new Paid(); }
    public OrderState ship() { throw new IllegalStateException("pay first"); }
    public String name() { return "CREATED"; }
}
final class Paid implements OrderState {
    public OrderState pay() { throw new IllegalStateException("already paid"); }
    public OrderState ship() { return new Shipped(); }
    public String name() { return "PAID"; }
}
final class Shipped implements OrderState {
    public OrderState pay() { return this; }
    public OrderState ship() { return this; }
    public String name() { return "SHIPPED"; }
}
final class Order {
    private OrderState state = new Created();
    void pay() { state = state.pay(); }
    void ship() { state = state.ship(); }
    public String toString() { return state.name(); }
}

class StateDemo {
    public static void main(String[] args) {
        Order o = new Order();
        o.pay();
        o.ship();
        System.out.println(o); // SHIPPED
    }
}

interface Pricing { int price(int cents); }
final class FullPrice implements Pricing {
    public int price(int c) {
        if (c < 0) throw new IllegalArgumentException("negative cents");
        return c;
    }
}
final class PercentOff implements Pricing {
    private final int pct;
    PercentOff(int pct) {
        if (pct < 0 || pct > 100) throw new IllegalArgumentException("percentage outside 0..100");
        this.pct = pct;
    }
    public int price(int c) {
        if (c < 0) throw new IllegalArgumentException("negative cents");
        return (int) ((long) c * (100 - pct) / 100); // floor final nonnegative cents
    }
}
final class Cart {
    private Pricing pricing = new FullPrice();
    void setPricing(Pricing p) { this.pricing = java.util.Objects.requireNonNull(p); }
    int checkout(int cents) { return pricing.price(cents); }
}

class StrategyDemo {
    public static void main(String[] args) {
        Cart cart = new Cart();
        System.out.println(cart.checkout(1000)); // 1000
        cart.setPricing(new PercentOff(20));
        System.out.println(cart.checkout(1000)); // 800
    }
}

abstract class DataJob {
    final void run() {              // template — final so order cannot change
        extract();
        transform();
        load();
    }
    abstract void extract();
    abstract void transform();
    void load() { System.out.println("load warehouse"); } // default step
}
final class CsvJob extends DataJob {
    void extract() { System.out.println("read csv"); }
    void transform() { System.out.println("normalize rows"); }
}

class TemplateDemo {
    public static void main(String[] args) {
        new CsvJob().run();
    }
}

interface Visitor {
    void visit(Lit n);
    void visit(AddNode n);
}
interface Node { void accept(Visitor v); int eval(); }

final class Lit implements Node {
    final int v;
    Lit(int v) { this.v = v; }
    public void accept(Visitor v) { v.visit(this); }
    public int eval() { return v; }
}
final class AddNode implements Node {
    final Node l, r;
    AddNode(Node l, Node r) { this.l = l; this.r = r; }
    public void accept(Visitor v) { v.visit(this); }
    public int eval() { return l.eval() + r.eval(); }
}
final class PrintVisitor implements Visitor {
    public void visit(Lit n) { System.out.print(n.v); }
    public void visit(AddNode n) {
        System.out.print("(");
        n.l.accept(this);
        System.out.print("+");
        n.r.accept(this);
        System.out.print(")");
    }
}

class VisitorDemo {
    public static void main(String[] args) {
        Node ast = new AddNode(new Lit(1), new AddNode(new Lit(2), new Lit(3)));
        ast.accept(new PrintVisitor()); // (1+(2+3))
        System.out.println(" = " + ast.eval());
    }
}

interface Logger { void info(String m); }
final class ConsoleLogger implements Logger {
    public void info(String m) { System.out.println(m); }
}
final class SilentLogger implements Logger {
    public void info(String m) { /* no-op */ }
}
final class Service {
    private final Logger log;
    Service(Logger log) { this.log = log; }
    void work() { log.info("working"); }
}

class NullObjectDemo {
    public static void main(String[] args) {
        new Service(new ConsoleLogger()).work();
        new Service(new SilentLogger()).work(); // no NPE, no output
    }
}

final class User {
    final String id, email;
    User(String id, String email) { this.id = id; this.email = email; }
}
interface UserRepository {
    void save(User u);
    User findById(String id); // null if absent in this minimal API; Optional is another choice
}
final class InMemoryUserRepository implements UserRepository {
    private final java.util.Map<String, User> db = new java.util.HashMap<String, User>();
    public void save(User u) { db.put(u.id, u); }
    public User findById(String id) { return db.get(id); }
}

class DaoDemo {
    public static void main(String[] args) {
        UserRepository repo = new InMemoryUserRepository();
        repo.save(new User("1", "a@x.com"));
        System.out.println(repo.findById("1").email);
    }
}

interface Clock { long now(); }
final class Billing {
    private final Clock clock;
    Billing(Clock clock) { this.clock = clock; }  // injected
    boolean overdue(long dueEpochMs) { return clock.now() > dueEpochMs; }
}

class DiDemo {
    public static void main(String[] args) {
        Billing real = new Billing(new Clock() {
            public long now() { return System.currentTimeMillis(); }
        });
        Billing test = new Billing(new Clock() {
            public long now() { return 100L; }
        });
        System.out.println(test.overdue(50));  // true, deterministic
        System.out.println(real.overdue(0));
    }
}

final class CounterModel {
    private int n;
    int get() { return n; }
    void inc() { n++; }
}
final class CounterView {
    void render(int n) { System.out.println("count=" + n); }
}
final class CounterController {
    private final CounterModel model;
    private final CounterView view;
    CounterController(CounterModel m, CounterView v) { model = m; view = v; }
    void onClick() { model.inc(); view.render(model.get()); }
}

class MvcDemo {
    public static void main(String[] args) {
        CounterController c = new CounterController(new CounterModel(), new CounterView());
        c.onClick();
        c.onClick();
    }
}

class ProducerConsumerDemo {
    public static void main(String[] args) throws InterruptedException, java.util.concurrent.ExecutionException {
        final java.util.concurrent.BlockingQueue<Integer> q =
                new java.util.concurrent.ArrayBlockingQueue<Integer>(2);
        java.util.concurrent.ExecutorService workers = java.util.concurrent.Executors.newFixedThreadPool(2);
        java.util.concurrent.CompletionService<Void> completed =
                new java.util.concurrent.ExecutorCompletionService<Void>(workers);
        try {
            completed.submit(() -> {
                for (int i = 0; i < 5; i++) q.put(i);
                q.put(-1); // reserved sentinel; exactly one consumer
                return null;
            });
            completed.submit(() -> {
                while (true) {
                    int value = q.take();
                    if (value == -1) return null;
                    System.out.println("got " + value);
                }
            });
            // Observe whichever task completes/fails first, not a fixed join order.
            for (int i = 0; i < 2; i++) completed.take().get();
        } finally {
            workers.shutdownNow(); // interrupts a peer blocked in put/take on failure/cancellation
        }
    }
}

final class Money {
    private final String currency;
    private final long cents;
    Money(String currency, long cents) {
        if (currency == null) throw new IllegalArgumentException();
        this.currency = currency;
        this.cents = cents;
    }
    String currency() { return currency; }
    long cents() { return cents; }
    Money plus(Money o) {
        java.util.Objects.requireNonNull(o);
        if (!currency.equals(o.currency)) throw new IllegalArgumentException("fx");
        return new Money(currency, Math.addExact(cents, o.cents)); // reject long overflow
    }
    @Override public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof Money)) return false;
        Money money = (Money) other;
        return cents == money.cents && currency.equals(money.currency);
    }
    @Override public int hashCode() {
        return 31 * currency.hashCode() + Long.hashCode(cents);
    }
}

class ImmutableDemo {
    public static void main(String[] args) {
        Money a = new Money("USD", 100);
        Money b = a.plus(new Money("USD", 50));
        System.out.println(a.cents() + " then " + b.cents()); // 100 then 150
    }
}

interface Auditable {} // marker
final class Payment implements Auditable {
    final long id;
    Payment(long id) { this.id = id; }
}

class MarkerDemo {
    static void audit(Object o) {
        if (o instanceof Auditable) System.out.println("audit " + o.getClass().getSimpleName());
        else System.out.println("skip");
    }
    public static void main(String[] args) {
        audit(new Payment(1));
        audit("nope");
    }
}

interface Action { void exec(String body); }
final class FrontController {
    private final java.util.Map<String, Action> routes = new java.util.HashMap<String, Action>();
    FrontController register(String path, Action a) { routes.put(path, a); return this; }
    void handle(String path, String body) {
        Action a = routes.get(path);
        if (a == null) { System.out.println("404 " + path); return; }
        a.exec(body);
    }
}

class FrontControllerDemo {
    public static void main(String[] args) {
        new FrontController()
                .register("/health", new Action() { public void exec(String b) { System.out.println("ok"); } })
                .register("/echo", new Action() { public void exec(String b) { System.out.println(b); } })
                .handle("/echo", "hi");
    }
}

final class ServiceLocator {
    private static final java.util.Map<Class<?>, Object> REG = new java.util.HashMap<Class<?>, Object>();
    static synchronized <T> void put(Class<T> type, T impl) {
        REG.put(java.util.Objects.requireNonNull(type), java.util.Objects.requireNonNull(type.cast(impl)));
    }
    static synchronized <T> T get(Class<T> type) {
        Object value = REG.get(java.util.Objects.requireNonNull(type));
        if (value == null) throw new IllegalStateException("unregistered: " + type.getName());
        return type.cast(value);
    }
}

class ServiceLocatorDemo {
    public static void main(String[] args) {
        ServiceLocator.put(Runnable.class, new Runnable() {
            public void run() { System.out.println("from locator"); }
        });
        ServiceLocator.get(Runnable.class).run();
    }
}