Interface segregation in depth

const money = (c: number): string => `${Math.floor(c / 100)}.${String(c % 100).padStart(2, "0")}`;

// One interface per kind of caller, holding exactly what that caller needs.
interface CustomerPanel { menu(): [string, number][]; buy(item: string, paid: number): number; } // buy returns change
interface RestockPanel { addStock(item: string, qty: number): number; }                         // returns new count
interface ServicePanel { selfTest(): string; collectCash(): number; }

// One machine can play all three roles; each caller only ever sees its own.
class VendingMachine implements CustomerPanel, RestockPanel, ServicePanel {
  private stock = new Map<string, number>();
  private cash = 0;
  constructor(private prices: Map<string, number>) { for (const item of prices.keys()) this.stock.set(item, 0); }
  menu(): [string, number][] { return [...this.prices].filter(([i]) => (this.stock.get(i) ?? 0) > 0); }
  buy(item: string, paid: number): number {
    const price = this.prices.get(item) ?? Infinity;
    if ((this.stock.get(item) ?? 0) === 0 || paid < price) throw new Error("cannot sell");
    this.stock.set(item, (this.stock.get(item) ?? 0) - 1);
    this.cash += price;
    return paid - price;
  }
  addStock(item: string, qty: number): number { this.stock.set(item, (this.stock.get(item) ?? 0) + qty); return this.stock.get(item) ?? 0; }
  selfTest(): string { return [...this.stock.values()].every((q) => q >= 0) ? "ok" : "fault"; }
  collectCash(): number { const taken = this.cash; this.cash = 0; return taken; }
}

function customerVisit(panel: CustomerPanel): void {
  console.log("menu: " + panel.menu().map(([i, p]) => `${i} ${money(p)}`).join(", "));
  console.log(`bought Cola with 2.00, change ${money(panel.buy("Cola", 200))}`);
}
function restockRound(panel: RestockPanel): void { console.log(`restocked Water: ${panel.addStock("Water", 7)} in stock`); }
function engineerVisit(panel: ServicePanel): void { console.log(`engineer: self-test ${panel.selfTest()}, collected ${money(panel.collectCash())}`); }

const machine = new VendingMachine(new Map([["Cola", 150], ["Water", 100]]));
machine.addStock("Cola", 5);
machine.addStock("Water", 5);
customerVisit(machine);
restockRound(machine);
engineerVisit(machine);

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

// One interface per kind of caller, holding exactly what that caller needs.
interface CustomerPanel {
    List<Map.Entry<String, Integer>> menu();
    int buy(String item, int paid); // returns change
}

interface RestockPanel {
    int addStock(String item, int qty); // returns new count
}

interface ServicePanel {
    String selfTest();
    int collectCash();
}

// One machine can play all three roles; each caller only ever sees its own.
class VendingMachine implements CustomerPanel, RestockPanel, ServicePanel {
    private final Map<String, Integer> prices;
    private final Map<String, Integer> stock = new LinkedHashMap<>();
    private int cash = 0;

    VendingMachine(Map<String, Integer> prices) {
        this.prices = prices;
        prices.keySet().forEach(i -> stock.put(i, 0));
    }

    public List<Map.Entry<String, Integer>> menu() {
        List<Map.Entry<String, Integer>> out = new ArrayList<>();
        prices.forEach((i, p) -> { if (stock.get(i) > 0) out.add(Map.entry(i, p)); });
        return out;
    }

    public int buy(String item, int paid) {
        int price = prices.get(item);
        if (stock.get(item) == 0 || paid < price) throw new IllegalStateException("cannot sell");
        stock.put(item, stock.get(item) - 1);
        cash += price;
        return paid - price;
    }

    public int addStock(String item, int qty) { stock.put(item, stock.get(item) + qty); return stock.get(item); }
    public String selfTest() { return stock.values().stream().allMatch(q -> q >= 0) ? "ok" : "fault"; }
    public int collectCash() { int taken = cash; cash = 0; return taken; }
}

public class Main {
    static String money(int c) { return (c / 100) + "." + String.format("%02d", c % 100); }

    static void customerVisit(CustomerPanel panel) {
        System.out.println("menu: " + panel.menu().stream().map(e -> e.getKey() + " " + money(e.getValue())).collect(Collectors.joining(", ")));
        System.out.println("bought Cola with 2.00, change " + money(panel.buy("Cola", 200)));
    }
    static void restockRound(RestockPanel panel) { System.out.println("restocked Water: " + panel.addStock("Water", 7) + " in stock"); }
    static void engineerVisit(ServicePanel panel) { System.out.println("engineer: self-test " + panel.selfTest() + ", collected " + money(panel.collectCash())); }

    public static void main(String[] args) {
        Map<String, Integer> prices = new LinkedHashMap<>();
        prices.put("Cola", 150);
        prices.put("Water", 100);
        VendingMachine machine = new VendingMachine(prices);
        machine.addStock("Cola", 5);
        machine.addStock("Water", 5);
        customerVisit(machine);
        restockRound(machine);
        engineerVisit(machine);
    }
}