Factory method

// ---- The products: what a dock hands to a rider. Callers only ever see Vehicle. ----
abstract class Vehicle {
  constructor(readonly vid: string) {}
  abstract describe(): string;
  abstract pencePerMinute(): number;
}

class Bike extends Vehicle {
  describe(): string { return `bike ${this.vid} (pedal only)`; }
  pencePerMinute(): number { return 10; }
}

class EBike extends Vehicle {
  constructor(vid: string, readonly battery: number) { super(vid); }
  describe(): string { return `e-bike ${this.vid} (battery ${this.battery}%)`; }
  pencePerMinute(): number { return 15; }
}

class Scooter extends Vehicle {
  constructor(vid: string, readonly maxKmh: number) { super(vid); }
  describe(): string { return `scooter ${this.vid} (max ${this.maxKmh} km/h)`; }
  pencePerMinute(): number { return 20; }
}

// ---- Factory method: release() is the same for every dock; each kind of dock decides what it creates. ----
abstract class Dock {
  constructor(readonly label: string, readonly name: string) {}

  release(vid: string): string {
    const vehicle = this.makeVehicle(vid);       // the factory method: no class named here
    return `${this.label} ${this.name} released ${vehicle.describe()} | ${vehicle.pencePerMinute()}p a minute`;
  }

  protected abstract makeVehicle(vid: string): Vehicle;
}

class ClassicDock extends Dock {
  constructor(name: string) { super("classic dock", name); }
  protected makeVehicle(vid: string): Vehicle { return new Bike(vid); }
}

class ChargingDock extends Dock {
  constructor(name: string, private readonly chargerReading: number) { super("charging dock", name); }
  protected makeVehicle(vid: string): Vehicle { return new EBike(vid, this.chargerReading); }   // uses the dock's own state
}

class ScooterBay extends Dock {                   // added later: no existing class was edited
  constructor(name: string, private readonly speedLimit: number) { super("scooter bay", name); }
  protected makeVehicle(vid: string): Vehicle { return new Scooter(vid, this.speedLimit); }
}

// ---- A simple factory: one function that turns a stored record into the right object. ----
const MAKERS: Record<string, (vid: string) => Vehicle> = {
  "bike": (vid) => new Bike(vid),
  "e-bike": (vid) => new EBike(vid, 100),
  "scooter": (vid) => new Scooter(vid, 15),
};

function vehicleFromRecord(kind: string, vid: string): Vehicle {
  const make = MAKERS[kind];
  if (!make) throw new Error(`unknown vehicle kind '${kind}'`);
  return make(vid);
}

const docks: Dock[] = [new ClassicDock("D1"), new ChargingDock("D7", 84), new ScooterBay("S2", 15)];
const vids = ["B-101", "E-205", "K-310"];
docks.forEach((dock, i) => console.log(dock.release(vids[i])));
const records: [string, string][] = [["bike", "B-101"], ["e-bike", "E-205"], ["scooter", "K-310"]];
console.log("loaded from records: " + records.map(([k, v]) => vehicleFromRecord(k, v).describe()).join(", "));
try {
  vehicleFromRecord("hoverboard", "H-1");
} catch (e) {
  console.log(`rejected: ${(e as Error).message}`);
}

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

public class Main {
    // ---- The products: what a dock hands to a rider. Callers only ever see Vehicle. ----
    abstract static class Vehicle {
        final String vid;
        Vehicle(String vid) { this.vid = vid; }
        abstract String describe();
        abstract int pencePerMinute();
    }

    static class Bike extends Vehicle {
        Bike(String vid) { super(vid); }
        String describe() { return "bike " + vid + " (pedal only)"; }
        int pencePerMinute() { return 10; }
    }

    static class EBike extends Vehicle {
        final int battery;
        EBike(String vid, int battery) { super(vid); this.battery = battery; }
        String describe() { return "e-bike " + vid + " (battery " + battery + "%)"; }
        int pencePerMinute() { return 15; }
    }

    static class Scooter extends Vehicle {
        final int maxKmh;
        Scooter(String vid, int maxKmh) { super(vid); this.maxKmh = maxKmh; }
        String describe() { return "scooter " + vid + " (max " + maxKmh + " km/h)"; }
        int pencePerMinute() { return 20; }
    }

    // ---- Factory method: release() is the same for every dock; each kind of dock decides what it creates. ----
    abstract static class Dock {
        final String label, name;
        Dock(String label, String name) { this.label = label; this.name = name; }

        String release(String vid) {
            Vehicle vehicle = makeVehicle(vid);   // the factory method: no class named here
            return label + " " + name + " released " + vehicle.describe() + " | " + vehicle.pencePerMinute() + "p a minute";
        }

        protected abstract Vehicle makeVehicle(String vid);
    }

    static class ClassicDock extends Dock {
        ClassicDock(String name) { super("classic dock", name); }
        protected Vehicle makeVehicle(String vid) { return new Bike(vid); }
    }

    static class ChargingDock extends Dock {
        private final int chargerReading;
        ChargingDock(String name, int chargerReading) { super("charging dock", name); this.chargerReading = chargerReading; }
        protected Vehicle makeVehicle(String vid) { return new EBike(vid, chargerReading); }   // uses the dock's own state
    }

    static class ScooterBay extends Dock {        // added later: no existing class was edited
        private final int speedLimit;
        ScooterBay(String name, int speedLimit) { super("scooter bay", name); this.speedLimit = speedLimit; }
        protected Vehicle makeVehicle(String vid) { return new Scooter(vid, speedLimit); }
    }

    // ---- A simple factory: one function that turns a stored record into the right object. ----
    static final Map<String, Function<String, Vehicle>> MAKERS = Map.of(
        "bike", Bike::new,
        "e-bike", vid -> new EBike(vid, 100),
        "scooter", vid -> new Scooter(vid, 15));

    static Vehicle vehicleFromRecord(String kind, String vid) {
        Function<String, Vehicle> make = MAKERS.get(kind);
        if (make == null) throw new IllegalArgumentException("unknown vehicle kind '" + kind + "'");
        return make.apply(vid);
    }

    public static void main(String[] args) {
        List<Dock> docks = List.of(new ClassicDock("D1"), new ChargingDock("D7", 84), new ScooterBay("S2", 15));
        String[] vids = {"B-101", "E-205", "K-310"};
        for (int i = 0; i < docks.size(); i++) System.out.println(docks.get(i).release(vids[i]));
        String[][] records = {{"bike", "B-101"}, {"e-bike", "E-205"}, {"scooter", "K-310"}};
        List<String> loaded = new ArrayList<>();
        for (String[] r : records) loaded.add(vehicleFromRecord(r[0], r[1]).describe());
        System.out.println("loaded from records: " + String.join(", ", loaded));
        try {
            vehicleFromRecord("hoverboard", "H-1");
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
    }
}