Abstract factory

// ---- One interface per part of a station. ----
interface Lock { describe(): string; radio(): string; }
interface Terminal { describe(): string; radio(): string; }
interface Display { show(text: string): string; }

// ---- London's family: everything talks NFC, signs are in English. ----
class BoltLock implements Lock { describe() { return "bolt lock"; } radio() { return "nfc"; } }
class ContactlessReader implements Terminal { describe() { return "contactless reader"; } radio() { return "nfc"; } }
class EInkSign implements Display { show(text: string) { return `e-ink sign: '${text}'`; } }

// ---- Paris's family: everything talks Bluetooth, signs are in French. ----
class MagneticLock implements Lock { describe() { return "magnetic lock"; } radio() { return "ble"; } }
class ChipPinPad implements Terminal { describe() { return "chip-and-PIN pad"; } radio() { return "ble"; } }
class LcdSign implements Display { show(text: string) { return `LCD sign: '${text}'`; } }

// ---- Abstract factory: one object that makes a whole matching family. ----
interface CityKit {
  makeLock(): Lock;
  makeTerminal(): Terminal;
  makeDisplay(): Display;
  welcome(): string;
}

class LondonKit implements CityKit {
  makeLock(): Lock { return new BoltLock(); }
  makeTerminal(): Terminal { return new ContactlessReader(); }
  makeDisplay(): Display { return new EInkSign(); }
  welcome() { return "Welcome to Pedal"; }
}

class ParisKit implements CityKit {
  makeLock(): Lock { return new MagneticLock(); }
  makeTerminal(): Terminal { return new ChipPinPad(); }
  makeDisplay(): Display { return new LcdSign(); }
  welcome() { return "Bienvenue chez Pedal"; }
}

// ---- The client: builds a station from whichever kit it is given, naming no concrete class. ----
class Station {
  constructor(readonly name: string, readonly lock: Lock, readonly terminal: Terminal, readonly sign: string) {}

  check(): string {
    if (this.lock.radio() !== this.terminal.radio()) return `mismatch: lock ${this.lock.radio()}, terminal ${this.terminal.radio()}`;
    return `ok (all ${this.lock.radio()})`;
  }
}

function installStation(name: string, kit: CityKit): Station {
  const display = kit.makeDisplay();
  return new Station(name, kit.makeLock(), kit.makeTerminal(), display.show(kit.welcome()));
}

const cities: [string, CityKit][] = [["LS-12", new LondonKit()], ["PS-03", new ParisKit()]];
for (const [name, kit] of cities) {
  const s = installStation(name, kit);
  console.log(`${s.name}: ${s.lock.describe()} + ${s.terminal.describe()} + ${s.sign} -> ${s.check()}`);
}
// Without a kit, nothing stops someone wiring a London lock to a Paris terminal.
const handWired = new Station("XX-01", new BoltLock(), new ChipPinPad(), "no sign");
console.log(`${handWired.name}: ${handWired.lock.describe()} + ${handWired.terminal.describe()} -> ${handWired.check()}`);

import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
    // ---- One interface per part of a station. ----
    interface Lock { String describe(); String radio(); }
    interface Terminal { String describe(); String radio(); }
    interface Display { String show(String text); }

    // ---- London's family: everything talks NFC, signs are in English. ----
    static class BoltLock implements Lock { public String describe() { return "bolt lock"; } public String radio() { return "nfc"; } }
    static class ContactlessReader implements Terminal { public String describe() { return "contactless reader"; } public String radio() { return "nfc"; } }
    static class EInkSign implements Display { public String show(String text) { return "e-ink sign: '" + text + "'"; } }

    // ---- Paris's family: everything talks Bluetooth, signs are in French. ----
    static class MagneticLock implements Lock { public String describe() { return "magnetic lock"; } public String radio() { return "ble"; } }
    static class ChipPinPad implements Terminal { public String describe() { return "chip-and-PIN pad"; } public String radio() { return "ble"; } }
    static class LcdSign implements Display { public String show(String text) { return "LCD sign: '" + text + "'"; } }

    // ---- Abstract factory: one object that makes a whole matching family. ----
    interface CityKit {
        Lock makeLock();
        Terminal makeTerminal();
        Display makeDisplay();
        String welcome();
    }

    static class LondonKit implements CityKit {
        public Lock makeLock() { return new BoltLock(); }
        public Terminal makeTerminal() { return new ContactlessReader(); }
        public Display makeDisplay() { return new EInkSign(); }
        public String welcome() { return "Welcome to Pedal"; }
    }

    static class ParisKit implements CityKit {
        public Lock makeLock() { return new MagneticLock(); }
        public Terminal makeTerminal() { return new ChipPinPad(); }
        public Display makeDisplay() { return new LcdSign(); }
        public String welcome() { return "Bienvenue chez Pedal"; }
    }

    // ---- The client: builds a station from whichever kit it is given, naming no concrete class. ----
    record Station(String name, Lock lock, Terminal terminal, String sign) {
        String check() {
            if (!lock.radio().equals(terminal.radio())) return "mismatch: lock " + lock.radio() + ", terminal " + terminal.radio();
            return "ok (all " + lock.radio() + ")";
        }
    }

    static Station installStation(String name, CityKit kit) {
        Display display = kit.makeDisplay();
        return new Station(name, kit.makeLock(), kit.makeTerminal(), display.show(kit.welcome()));
    }

    public static void main(String[] args) {
        Map<String, CityKit> cities = new LinkedHashMap<>();
        cities.put("LS-12", new LondonKit());
        cities.put("PS-03", new ParisKit());
        for (Map.Entry<String, CityKit> e : cities.entrySet()) {
            Station s = installStation(e.getKey(), e.getValue());
            System.out.println(s.name() + ": " + s.lock().describe() + " + " + s.terminal().describe() + " + " + s.sign() + " -> " + s.check());
        }
        // Without a kit, nothing stops someone wiring a London lock to a Paris terminal.
        Station handWired = new Station("XX-01", new BoltLock(), new ChipPinPad(), "no sign");
        System.out.println(handWired.name() + ": " + handWired.lock().describe() + " + " + handWired.terminal().describe() + " -> " + handWired.check());
    }
}