Problem 8: Design a Vending Machine

The setup

"Design a vending machine. User inserts coins/notes, selects an item, receives the item and change. Machine has inventory of multiple items with prices."

The vending machine is the canonical State pattern problem. It has explicit operational states (idle, has money, item selected, dispensing) with allowed transitions and behavior that varies per state.

Clarifying questions

The State machine

States:
  IDLE              — waiting for money or selection
  HAS_MONEY         — money inserted; waiting for item selection
  ITEM_SELECTED     — item chosen; verifying funds, preparing to dispense
  DISPENSING        — item physically released
  RETURNING_CHANGE  — releasing change
  
Transitions:
  IDLE + insert_money → HAS_MONEY (or stays IDLE if invalid)
  HAS_MONEY + insert_more_money → HAS_MONEY (accumulate)
  HAS_MONEY + select_item → ITEM_SELECTED (if balance >= price)
  HAS_MONEY + cancel → IDLE (refund)
  ITEM_SELECTED + confirm → DISPENSING
  DISPENSING + done → RETURNING_CHANGE (if change > 0) or IDLE
  RETURNING_CHANGE + done → IDLE

interface MachineState {
  void insertMoney(VendingMachine machine, Money money);
  void selectItem(VendingMachine machine, String itemId);
  void cancel(VendingMachine machine);
  // Some states may make some methods no-ops or errors
}

class IdleState implements MachineState {
  public void insertMoney(VendingMachine machine, Money money) {
    machine.addInsertedAmount(money.value);
    machine.transitionTo(new HasMoneyState());
  }
  public void selectItem(VendingMachine machine, String itemId) {
    // No money inserted; reject
    machine.displayMessage("Please insert money first");
  }
  public void cancel(VendingMachine machine) {}  // noop
}

class HasMoneyState implements MachineState {
  public void insertMoney(VendingMachine machine, Money money) {
    machine.addInsertedAmount(money.value);  // accumulate
  }
  public void selectItem(VendingMachine machine, String itemId) {
    Item item = machine.getInventory().getItem(itemId);
    if (item == null || item.quantity == 0) {
      machine.displayMessage("Item unavailable");
      return;
    }
    if (machine.insertedAmount.compareTo(item.price) < 0) {
      machine.displayMessage("Insufficient funds; need " 
          + item.price.subtract(machine.insertedAmount) + " more");
      return;
    }
    // Check change availability
    BigDecimal changeNeeded = machine.insertedAmount.subtract(item.price);
    if (!machine.canMakeChange(changeNeeded)) {
      machine.displayMessage("Exact change required");
      machine.refund();
      machine.transitionTo(new IdleState());
      return;
    }
    machine.setSelectedItem(item);
    machine.transitionTo(new ItemSelectedState());
  }
  public void cancel(VendingMachine machine) {
    machine.refund();
    machine.transitionTo(new IdleState());
  }
}

class ItemSelectedState implements MachineState {
  public void selectItem(VendingMachine machine, String itemId) {
    // Same as confirm — proceed to dispense
    machine.dispenseSelectedItem();
    machine.transitionTo(new DispensingState());
  }
  // Cancel still refunds
}

class DispensingState implements MachineState {
  // Most operations rejected during physical dispense
  // After dispense, transition to RETURNING_CHANGE or IDLE
}

The VendingMachine class

class VendingMachine {
  private MachineState state;
  private Inventory inventory;
  private CoinInventory coinInventory;  // tracks coins/notes available for change
  private BigDecimal insertedAmount;
  private Item selectedItem;
  
  public void insertMoney(Money money) { state.insertMoney(this, money); }
  public void selectItem(String itemId) { state.selectItem(this, itemId); }
  public void cancel() { state.cancel(this); }
  
  void transitionTo(MachineState newState) { this.state = newState; }
  
  void dispenseSelectedItem() {
    BigDecimal change = insertedAmount.subtract(selectedItem.price);
    // Physically dispense the item
    inventory.removeItem(selectedItem.id);
    coinInventory.addAmount(selectedItem.price);  // money goes into machine
    if (change.signum() > 0) {
      List coinsForChange = coinInventory.makeChange(change);
      // Physically dispense change
    }
    // Reset
    insertedAmount = BigDecimal.ZERO;
    selectedItem = null;
    transitionTo(new IdleState());
  }
}

Cross-examination round 1: change-making

Takeaway

Vending machines are the State pattern's textbook example. Each state defines its allowed operations and transitions. Adding new operations or states is localised. This is far cleaner than a giant switch on a state enum inside one class.