Vending machine
The State pattern's home ground.

IDLE ──selectProduct──▶ PRODUCT_SELECTED ──insertMoney (enough)──▶ DISPENSING ──▶ IDLE
  ▲                         │    ▲ insertMoney (not enough; stay)
  │                         │    └──────────┘
  └──────── cancel (refund) ┘

enum Coin {
    ONE(1), TWO(2), FIVE(5), TEN(10), TWENTY(20);
    final int value; Coin(int v) { value = v; }
}

record Product(String code, String name, int price) {}

class Inventory {
    private final Map<String, Product> products = new HashMap<>();
    private final Map<String, Integer> stock = new HashMap<>();
    void restock(Product p, int qty) { products.put(p.code(), p); stock.merge(p.code(), qty, Integer::sum); }
    Product get(String code) { return products.get(code); }
    boolean available(String code) { return stock.getOrDefault(code, 0) > 0; }
    void decrement(String code) { stock.merge(code, -1, Integer::sum); }
}

class CashBox {
    private final EnumMap<Coin, Integer> coins = new EnumMap<>(Coin.class);
    void add(List<Coin> in) { in.forEach(c -> coins.merge(c, 1, Integer::sum)); }

    /** Greedy change-making (works for canonical coin systems); returns empty if exact change is impossible. */
    Optional<List<Coin>> makeChange(int amount) {
        List<Coin> result = new ArrayList<>();
        EnumMap<Coin, Integer> temp = new EnumMap<>(coins);
        Coin[] desc = Coin.values(); Arrays.sort(desc, Comparator.comparingInt((Coin c) -> c.value).reversed());
        for (Coin c : desc) {
            while (amount >= c.value && temp.getOrDefault(c, 0) > 0) {
                amount -= c.value; temp.merge(c, -1, Integer::sum); result.add(c);
            }
        }
        if (amount != 0) return Optional.empty();
        coins.clear(); coins.putAll(temp);                           // commit
        return Optional.of(result);
    }
}

interface State {
    default void selectProduct(VendingMachine m, String code) { throw new IllegalStateException("Cannot select now"); }
    default void insertMoney(VendingMachine m, Coin coin)     { throw new IllegalStateException("Cannot insert money now"); }
    default void cancel(VendingMachine m)                     { /* no-op by default */ }
    default void dispense(VendingMachine m)                   { throw new IllegalStateException("Cannot dispense now"); }
}

class IdleState implements State {
    public void selectProduct(VendingMachine m, String code) {
        if (!m.inventory().available(code)) throw new IllegalStateException("Sold out: " + code);
        m.setSelected(m.inventory().get(code));
        m.setState(new ProductSelectedState());
    }
}

class ProductSelectedState implements State {
    public void insertMoney(VendingMachine m, Coin coin) {
        m.addInserted(coin);
        if (m.insertedTotal() >= m.selected().price()) {
            m.setState(new DispensingState());
            m.dispense();
        }
    }
    public void cancel(VendingMachine m) {
        m.returnCoins(m.clearInserted());
        m.reset();
    }
}

class DispensingState implements State {
    public void dispense(VendingMachine m) {
        int change = m.insertedTotal() - m.selected().price();
        m.cashBox().add(m.insertedCoins());                          // put the coins in the box first: they can be used for change
        Optional<List<Coin>> changeCoins = m.cashBox().makeChange(change);
        if (changeCoins.isEmpty()) {                                 // can't give change → refund, abort
            m.cashBox().makeChange(m.insertedTotal()).ifPresent(m::returnCoins);
            m.clearInserted(); m.reset();
            throw new IllegalStateException("Cannot make change, money refunded");
        }
        m.inventory().decrement(m.selected().code());
        m.release(m.selected());
        m.returnCoins(changeCoins.get());
        m.clearInserted(); m.reset();
    }
}

class VendingMachine {
    private State state = new IdleState();
    private final Inventory inventory = new Inventory();
    private final CashBox cashBox = new CashBox();
    private Product selected;
    private final List<Coin> inserted = new ArrayList<>();

    // Public API: delegate to the current state (synchronised: one physical user at a time)
    public synchronized void selectProduct(String code) { state.selectProduct(this, code); }
    public synchronized void insertMoney(Coin coin)     { state.insertMoney(this, coin); }
    public synchronized void cancel()                   { state.cancel(this); }
    synchronized void dispense()                        { state.dispense(this); }

    // Package-private helpers used by the states
    void setState(State s) { state = s; }
    void setSelected(Product p) { selected = p; }
    Product selected() { return selected; }
    void addInserted(Coin c) { inserted.add(c); }
    int insertedTotal() { return inserted.stream().mapToInt(c -> c.value).sum(); }
    List<Coin> insertedCoins() { return List.copyOf(inserted); }
    List<Coin> clearInserted() { List<Coin> c = List.copyOf(inserted); inserted.clear(); return c; }
    void reset() { selected = null; state = new IdleState(); }
    Inventory inventory() { return inventory; } CashBox cashBox() { return cashBox; }
    void release(Product p) { System.out.println("Dispensed " + p.name()); }
    void returnCoins(List<Coin> coins) { System.out.println("Returned " + coins); }
}