Vending Machine System - State Pattern Implementation
This is an implementation of the State design pattern for a vending machine system where the machine changes its behavior based on its internal state, completely eliminating the need for massive if/else conditional blocks.
Problem Statement
Building the software for a Vending Machine that transitions between four distinct states: Idle, Has Money, Dispensing, and Out of Stock. The challenge is ensuring that actions (like inserting money or selecting an item) behave differently depending on the current state, without hardcoding conditional logic into the main machine class.
Key Challenge:
- If
selectItem()is called in the Idle state → "Please insert money first." - If
selectItem()is called in the Has Money state → Transition to dispensing and output "Dispensing your item." - The machine must handle state transitions internally and gracefully reject invalid actions (like inserting money when out of stock).
Class Diagram
+----------------------+
| VendingMachine | <-------------------+
+----------------------+ |
| - currentState | |
| - inventory | |
+----------------------+ |
| + setState() | |
| + insertMoney() | |
| + selectItem() | |
+----------+-----------+ |
| |
| (Delegates to) |
v |
+----------------------+ |
| State | |
| (Interface) | |
+----------------------+ |
| + insertMoney() | |
| + selectItem() | |
| + dispenseItem() | |
+----------+-----------+ |
^ |
| (Implements) |
+--------------------------+--------------------------+ |
| | | |
+----------+----------+ +----------+----------+ +----------+------+-+
| IdleState | | HasMoneyState | | DispensingState |
+---------------------+ +---------------------+ +-------------------+
| - machine |--->| - machine |--->| - machine |
| + insertMoney() | | + insertMoney() | | + insertMoney() |
+---------------------+ +---------------------+ +-------------------+
Implementation
(Note: I updated IdealState to IdleState to match standard naming conventions).
package state.vendingmachinesystem;
public class VendingMachineSystem {
/**
* State Interface.
* Defines the common actions that can be performed in any state.
*/
interface State {
void insertMoney();
void selectItem();
void dispenseItem();
}
/**
* Context Class.
* Maintains a reference to an instance of a State subclass,
* which represents the current state of the vending machine.
*/
static class VendingMachine {
State idleState;
State hasMoneyState;
State dispenseState;
State outOfStockState;
State currentState;
int inventory;
public VendingMachine(int inventory) {
// Initialize all possible states
idleState = new IdleState(this);
hasMoneyState = new HasMoneyState(this);
dispenseState = new DispensingState(this);
outOfStockState = new OutOfStockState(this);
this.inventory = inventory;
if (inventory > 0) {
currentState = idleState;
} else {
currentState = outOfStockState;
}
}
public void setState(State state) {
this.currentState = state;
}
// Action delegations to the current state
public void insertMoney() {
currentState.insertMoney();
}
public void selectItem() {
currentState.selectItem();
}
public void dispenseItem() {
currentState.dispenseItem();
}
}
/**
* Concrete State: Waiting for a user to insert money.
*/
static class IdleState implements State {
private final VendingMachine machine;
public IdleState(VendingMachine machine) {
this.machine = machine;
}
@Override
public void insertMoney() {
System.out.println("Money inserted. You can now select an item.");
machine.setState(machine.hasMoneyState);
}
@Override
public void selectItem() {
System.out.println("ERROR: Please insert money first");
}
@Override
public void dispenseItem() {
System.out.println("ERROR: Please insert money and select an item");
}
}
/**
* Concrete State: Money has been inserted, waiting for item selection.
*/
static class HasMoneyState implements State {
private final VendingMachine machine;
public HasMoneyState(VendingMachine machine) {
this.machine = machine;
}
@Override
public void insertMoney() {
System.out.println("ERROR: Money is already inserted");
}
@Override
public void selectItem() {
System.out.println("Item selected! Dispensing your item");
machine.setState(machine.dispenseState);
machine.dispenseItem();
}
@Override
public void dispenseItem() {
System.out.println("ERROR: You need to select an item first");
}
}
/**
* Concrete State: Currently pushing the item out of the machine.
*/
static class DispensingState implements State {
private final VendingMachine machine;
public DispensingState(VendingMachine machine) {
this.machine = machine;
}
@Override
public void insertMoney() {
System.out.println("ERROR: Please wait, dispensing in progress");
}
@Override
public void selectItem() {
System.out.println("ERROR: Already dispensing");
}
@Override
public void dispenseItem() {
machine.inventory--;
System.out.println("Item dispensed! Remaining inventory: " + machine.inventory);
if (machine.inventory > 0) {
machine.setState(machine.idleState);
} else {
System.out.println("Machine is now Out of Stock.");
machine.setState(machine.outOfStockState);
}
}
}
/**
* Concrete State: Inventory is zero.
*/
static class OutOfStockState implements State {
private VendingMachine machine;
public OutOfStockState(VendingMachine machine) {
this.machine = machine;
}
@Override
public void insertMoney() {
System.out.println("ERROR: Machine is out of stock. Returning money.");
}
@Override
public void selectItem() {
System.out.println("ERROR: Machine is out of stock");
}
@Override
public void dispenseItem() {
System.out.println("ERROR: Machine is out of stock");
}
}
/**
* Main driver method.
* The client interacts with the VendingMachine actions, unaware of
* the underlying state transitions happening dynamically.
*/
public static void main(String[] args) {
System.out.println("---- Vending Machine Booting Up ----");
VendingMachine machine = new VendingMachine(1);
System.out.println("\n---- Attempt 1: Just pressing select ----");
machine.selectItem();
System.out.println("\n---- Attempt 2: Happy Path ----");
machine.insertMoney();
machine.selectItem();
System.out.println("\n---- Attempt 3: Out of Stock ----");
machine.insertMoney();
}
}
Key Features
- State Pattern: Localizes behavior for different states into separate classes.
-
Eliminates Conditionals: Replaces messy, sprawling
if (state == X)statements with polymorphic method calls. - Single Responsibility: Each state class handles only the rules and transitions relevant to its specific context.
-
Open/Closed Principle: New states (e.g.,
MaintenanceState) can be added without drastically changing the existing context or other state classes. -
Dynamic Transitions: The context (
VendingMachine) alters its behavior at runtime as its internal state changes.
How It Works
-
Interface (
State): Dictates all possible interactions a user can have with the machine (insertMoney,selectItem,dispenseItem). -
Context (
VendingMachine): Holds a reference to thecurrentStateand passes client requests down to whatever state object currently occupies that variable. -
Concrete Classes (
IdleState,HasMoneyState, etc.): Provide specific implementations of the state logic and trigger the transition to the next state usingmachine.setState(). -
Client (
main): Just calls standard methods on the Context, blissfully unaware of the internal state swapping.
Sample Output
---- Vending Machine Booting Up ----
---- Attempt 1: Just pressing select ----
ERROR: Please insert money first
---- Attempt 2: Happy Path ----
Money inserted. You can now select an item.
Item selected! Dispensing your item
Item dispensed! Remaining inventory: 0
Machine is now Out of Stock.
---- Attempt 3: Out of Stock ----
ERROR: Machine is out of stock. Returning money.