Design A Vending Machine - Object-Oriented Design

Requirements

Vending Machine Overview

The VendingMachine will manage an inventory of products, each having a unique code number and associated price. The machine operates through a series of states that define its current operational mode.

States of the Vending Machine

Idle State
- The vending machine is ready for use.
- Users can view available products.
- Users can select a product to purchase.
Selection State
- Users have selected a product.
- The machine displays the selected product's details (e.g., price and code number).
- The machine prompts the user to insert payment.
Has Money State
- The machine is in the process of accepting user payment.
- Users can enter the required coins or notes to complete the transaction.
- The machine should provide an option to process a refund, ensuring users can retrieve their full payment if they decide to cancel the transaction before dispensing the product.
Dispense State
- The machine is actively dispensing the selected product.
- No other operations (such as selecting another product or inserting further payments) can occur during this state.
- Once the dispensing process is complete, the machine transitions back to the Idle State, ready for the next user.

Product Inventory

Each product in the inventory will have:
- Code Number: A unique identifier for the product.
- Price: The cost associated with the product.

Define Core Objects

Based on the requirements and use cases, identify the main objects of the system...

Item: Represents products with type and price.
ItemType Enum: Defines types of items (COKE, PEPSI, CHIPS).
ItemShelf: Contains an item with a specific code and sold-out status.
Inventory: Manages multiple item shelves, allowing the addition and retrieval of items.
VendingMachine: Represents the vending machine, integrating inventory management and state handling.
Coin Enum: Represents available coin denominations.

Analyze Relationships

Determine how these objects will interact with each other to fulfill the use cases...

VendingMachine and Inventory:
- The VendingMachine contains an instance of Inventory. This establishes a composition relationship, indicating that the vending machine is responsible for managing its inventory.
VendingMachine and State:
- The VendingMachine operates with the VendingMachineState interface, enabling it to manage state transitions. The relationship is characterized as a dependency, as the vending machine relies on the states to define its behavior.
State Implementations:
- Each state implementation (e.g., IdleState, SelectionState, HasMoneyState, DispenseState) derives from the VendingMachineState interface. This shows an inheritance relationship, where concrete states must implement the required methods defined by the interface.
Inventory and ItemShelf:
- The Inventory manages multiple ItemShelf instances, indicating a composition relationship. Each item shelf exists as part of the inventory, and the inventory manages their lifecycle.
ItemShelf and Item:
- Each ItemShelf contains an Item, representing a composition relationship where shelves are responsible for the items they hold. If an item is removed or sold out, the corresponding item shelf reflects that status.
Item and Enums:
- The Item class uses the ItemType enum to define the type of item. This establishes an association where the item type is an attribute but not a part of the item structure itself.

Establish Hierarchy

Design inheritance trees where applicable to promote code reuse and polymorphism. This step involves identifying common attributes and behaviors that can be abstracted into parent classes...

VendingMachine: Main controller managing inventory and current state. Contains methods for selecting items, processing payments, and dispensing products.
State Interface:
- VendingMachineState: Defines methods for all state implementations.
  - IdleState: Machine is ready for user interaction.
  - SelectionState: Manages item selection.
  - HasMoneyState: Handles payment processing.
  - DispenseState: Manages item dispensing.
Inventory: Manages an array of ItemShelf instances, coordinating item storage and retrieval.
ItemShelf: Contains an Item with a unique code and sold-out status.
Item: Represents products available in the machine, defined by type and price.
Enums:
- Coin: Defines coin denominations (ONE, FIVE, TEN, HUNDRED).
- ItemType: Enumerates item types (COKE, PEPSI, CHIPS).

Design Patterns

Consider using design patterns (e.g., Factory, Singleton, Observer, Strategy) that fit the problem

Singelton Design Pattern

Class VendingMachine {
private static instance=null;
private VendingMachine(){}
public VendingMachine getInstance(){
  if(instance==null)return new VendingMachine();
  else 
     return instance;
}
//other methods 
}

State Design Pattern

In the vending machine system, the State Design Pattern has been employed to manage the machine's operations through distinct states. This pattern ensures that the vending machine can perform specific operations allowed in one state while preventing any operations associated with other states. This structured approach has the following benefits:

interface State{
//methods 
selectProduct();
refundMoney();
dispenseProduct();
}
class IdelState implements State{
//overide the mehtods
// works for only specefic operations that is acceptable for IdelState and for other operation will throw 
}
class DispenseState Implements State{}
class SelectState Implements State{} 

Define Class Members (write code)

Vending Machine

public class VendingMachine{
    States state;
    Inventory inventory;
    List<Coin> coinList;
public List&lt;Coin&gt; getCoinList() {
    return coinList;
}

public VendingMachine() {
    this.coinList = new ArrayList&lt;&gt;();
    this.inventory = new Inventory(10);
    this.state = (States) new IdleState();
}

public void setCoinList(List&lt;Coin&gt; coinList) {
    this.coinList = coinList;
}

public States getState() {
    return state;
}

public void setState(States state) {
    this.state = state;
}

public Inventory getInventory() {
    return inventory;
}

public void setInventory(Inventory inventory) {
    this.inventory = inventory;
}

}

ItemShelf

public class ItemShelf {
    int code;
    Item item;
    boolean soldOut;

//    public ItemShelf(Item item, int code, boolean soldOut) {
//        this.item = item;
//        this.code = code;
//        this.soldOut = soldOut;
//    }
public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public Item getItem() {
        return item;
    }

    public void setItem(Item item) {
        this.item = item;
    }

    public boolean isSoldOut() {
        return soldOut;
    }

    public void setSoldOut(boolean soldOut) {
        this.soldOut = soldOut;
    }

}

Item

public class Item
{
ItemType type;
int price;
public ItemType getType() {
    return type;
}

public void setType(ItemType type) {
    this.type = type;
}

public int getPrice() {
    return price;
}

public void setPrice(int price) {
    this.price = price;
}

}

Inventory

public class Inventory
{
ItemShelf[] inventory=null;
// intialize inventory
// add item
// get Item By CodeNumber
// updateSoldout


public ItemShelf[] getInventory() {
    return inventory;
}

public void setInventory(ItemShelf[] inventory) {
    this.inventory = inventory;
}

public Inventory(int ItemCount) {
    inventory = new ItemShelf[ItemCount];
    intialInventory();
}
public void intialInventory() {
    int n=inventory.length;
    int startCode=100;
    for(int i=0;i&lt;n;i++) {
        ItemShelf itemShelf=new ItemShelf();
        itemShelf.code=startCode;
        itemShelf.item=null;
        itemShelf.soldOut=true;
        startCode++;
    }
}
public void addItem(int codeNumber, Item item)
{
    for(int i=0;i&lt;inventory.length;i++) {
        if(inventory[i].code==codeNumber) {
            inventory[i].item=item;
            inventory[i].soldOut=false;
        }
    }
}

public Item getItem(int code) throws Exception {
        for(int i=0;i&lt;inventory.length;i++) {
            if(inventory[i].code==code&amp;&amp; inventory[i].soldOut!=false) {
                return inventory[i].item;
            }
            else
                throw new Exception(&quot;Item already soled&quot;);
        }
        return null;
}
public void updateSoldOut(int codeNumber)
{
    for(int i=0;i&lt;inventory.length;i++) {
        if(inventory[i].code==codeNumber) {
            inventory[i].soldOut=true;
        }
    }
}

}

Coins

public enum Coin {
PENNY(1),
NICKEL(5),
DIME(10),
QUARTER(25);


public int value;
Coin(int value) {
    this.value = value;
}

}

ItemType

public enum ItemType
{
COKE,
PEPSI,
SODA,
CHIPS,
CHOCO
}

Dispense State

public class DispenseState implements States {
DispenseState (VendingMachine machine, int codeNumber)throws Exception
{
    System.out.println(&quot;Currently Vending machine is in DispenseState&quot;);
    dispenseProduct(machine, codeNumber);
}
@Override
public void clickOnInsertCoinButton(VendingMachine machine) throws Exception{
    throw new Exception(&quot;insert coin button can not clicked on Dispense state&quot;);
}
@Override
public void clickOnStartProductSelectionButton(VendingMachine machine) throws Exception {
    throw new Exception(&quot;product selection buttion can not be clicked in Dispense state&quot;);
}
@Override
public void insertCoin(VendingMachine machine, Coin coin) throws Exception{
    throw new Exception(&quot;coin can not be inserted in Dispense state&quot;);
}
@Override
public void chooseProduct(VendingMachine machine, int codeNumber) throws Exception{
    throw new Exception(&quot;product can not be choosen in Dispense state&quot;);
}
@Override
public int getChange(int returnChangeMoney) throws Exception{
    throw new Exception(&quot;change can not returned in Dispense state&quot;);
}
@Override
public List&lt;Coin&gt; refundFullMoney(VendingMachine machine) throws Exception{
    throw new Exception(&quot;refund can not be happen in Dispense state&quot;);
}
@Override
public Item dispenseProduct(VendingMachine machine, int codeNumber) throws Exception {

//        return null;
System.out.println("Product has been dispensed");
Item item = machine.getInventory().getItem(codeNumber);
machine.getInventory().updateSoldOut(codeNumber);
machine.setState(new IdleState(machine));
return item;
}
@Override
public void updateInventory(VendingMachine machine, Item item, int codeNumber) throws Exception {
}
}

HasMoneyState

public class HasMoneyState implements States
{
public HasMoneyState(){
System.out.println("Currently Vending machine is in HasMoneyState");
}
@Override
public void clickOnInsertCoinButton(VendingMachine machine) throws Exception {
return;
}
@Override
public void clickOnStartProductSelectionButton(VendingMachine machine) throws Exception {
machine.setState(new SelectionState());
}
@Override
public void insertCoin(VendingMachine machine, Coin coin) throws Exception {
System.out.println("Accepted the coin");
machine.getCoinList().add(coin);
}
@Override
public void chooseProduct(VendingMachine machine, int codeNumber) throws Exception {
throw new Exception("you need to click on start product selection button first");
}
@Override
public int getChange(int returnChangeMoney) throws Exception {
throw new Exception("you can not get change in hasMoney state");
}
@Override
public Item dispenseProduct(VendingMachine machine, int codeNumber) throws Exception {
throw new Exception("product can not be dispensed in hasMoney state");
}
@Override
public List<Coin> refundFullMoney(VendingMachine machine) throws Exception {
System.out.println("Returned the full amount back in the Coin Dispense Tray");
machine.setState(new IdleState(machine));
return machine.getCoinList();
}
@Override
public void updateInventory(VendingMachine machine, Item item, int codeNumber) throws Exception {
throw new Exception("you can not update inventory in hasMoney  state");
}
}

IdleState

public class IdleState implements States {
public IdleState(){
    System.out.println(&quot;Currently Vending machine is in IdleState&quot;);
}

public IdleState(VendingMachine machine){
    System.out.println(&quot;Currently Vending machine is in IdleState&quot;);
    machine.setCoinList(new ArrayList&lt;&gt;());
}

@Override
public void clickOnInsertCoinButton(VendingMachine machine) throws Exception{
    machine.setState(new HasMoneyState());
}

@Override
public void clickOnStartProductSelectionButton(VendingMachine machine) throws Exception {
    throw new Exception(&quot;first you need to click on insert coin button&quot;);

}

@Override
public void insertCoin(VendingMachine machine, Coin coin) throws Exception{
    throw new Exception(&quot;you can not insert Coin in idle state&quot;);
}

@Override
public void chooseProduct(VendingMachine machine, int codeNumber) throws Exception{
    throw new Exception(&quot;you can not choose Product in idle state&quot;);
}

@Override
public int getChange(int returnChangeMoney) throws Exception{
    throw new Exception(&quot;you can not get change in idle state&quot;);
}

@Override
public List&lt;Coin&gt; refundFullMoney(VendingMachine machine) throws Exception{
    throw new Exception(&quot;you can not get refunded in idle state&quot;);
}

@Override
public Item dispenseProduct(VendingMachine machine, int codeNumber) throws Exception{
    throw new Exception(&quot;proeduct can not be dispensed idle state&quot;);
}

@Override
public void updateInventory(VendingMachine machine, Item item, int codeNumber) throws Exception {
    machine.getInventory().addItem( codeNumber,item);
}

}

Selection State

public class SelectionState implements States {
public SelectionState(){
System.out.println("Currently Vending machine is in SelectionState");
}
@Override
public void clickOnInsertCoinButton(VendingMachine machine) throws Exception{
    throw new Exception(&quot;you can not click on insert coin button in Selection state&quot;);
}

@Override
public void clickOnStartProductSelectionButton(VendingMachine machine) throws Exception {
    return;
}

@Override
public void insertCoin(VendingMachine machine, Coin coin) throws Exception{
    throw new Exception(&quot;you can not insert Coin in selection state&quot;);
}

@Override
public void chooseProduct(VendingMachine machine, int codeNumber) throws Exception{

    //1. get item of this codeNumber
    Item item = machine.getInventory().getItem(codeNumber);

    //2. total amount paid by User
    int paidByUser = 0;
    for(Coin coin : machine.getCoinList()){
        paidByUser = paidByUser + coin.value;
    }

    //3. compare product price and amount paid by user
    if(paidByUser &lt; item.getPrice()) {
        System.out.println(&quot;Insufficient Amount, Product you selected is for price: &quot; + item.getPrice() + &quot; and you paid: &quot; + paidByUser);
        refundFullMoney(machine);
        throw new Exception(&quot;insufficient amount&quot;);
    }
    else if(paidByUser &gt;= item.getPrice()) {

        if(paidByUser &gt; item.getPrice()) {
            getChange(paidByUser-item.getPrice());
        }
        machine.setState(new DispenseState(machine, codeNumber));
    }
}

@Override
public int getChange(int returnExtraMoney) throws Exception{
    //actual logic should be to return COINs in the dispense tray, but for simplicity i am just returning the amount to be refunded
    System.out.println(&quot;Returned the change in the Coin Dispense Tray: &quot; + returnExtraMoney);
    return returnExtraMoney;
}

@Override
public List&lt;Coin&gt; refundFullMoney(VendingMachine machine) throws Exception{
    System.out.println(&quot;Returned the full amount back in the Coin Dispense Tray&quot;);
    machine.setState(new IdleState(machine));
    return machine.getCoinList();
}

@Override
public Item dispenseProduct(VendingMachine machine, int codeNumber) throws Exception{
    throw new Exception(&quot;product can not be dispensed Selection state&quot;);
}

@Override
public void updateInventory(VendingMachine machine, Item item, int codeNumber) throws Exception {
    throw new Exception(&quot;Inventory can not be updated in Selection state&quot;);
}

}

Adhere to SOLID Guidelines

Check and explain whether your design adheres to solid principles (Ask interviewer what SOLID principle is if you can not recall it.)...

Single Responsibility Principle (SRP):
- Our architecture follows the SRP, where each class (IdleState, SelectionState, DispenseState, HasMoneyState) has its own independent implementation, ensuring clear responsibilities.
Open/Closed Principle (OCP):
- We adhere to the OCP, allowing for the introduction of new state implementations without modifying existing classes.
Liskov Substitution Principle (LSP):
- Our design allows the VendingMachine to accept any child state object without causing application errors, maintaining functionality.
Interface Segregation Principle (ISP):
- Although the system has minimal interfaces, we utilize a single State interface that encompasses only the necessary methods required for concrete classes.
Dependency Inversion Principle (DIP):
- The system depends on abstractions (State interface) rather than concrete implementations, promoting flexibility and decoupling components.

Consider Scalability and Flexibility

Explain how your design can handle changes in scale and whether it would be easily to extend with new functionalities...

New State Introduction

The modular nature of the State Design Pattern allows for the easy introduction of additional states, such as Maintenance Mode and Out Of Order, without disrupting existing functionality.

Enum Usage

We have extensively utilized ENUs for ItemType and CoinType, enhancing extensibility. New types can be added seamlessly without modifying or retesting existing code.

Create/Explain your diagram(s)

Try creating a class, flow, state and/or sequence diagram using the diagramming tool. Mermaid flow diagrams can be used to represent system use cases. You can ask the interviewer bot to create a starter diagram if unfamiliar with the tool. Briefly explain your diagrams if necessary...

Item: Represents the product, containing attributes for item type and price.
ItemShelf: Holds an Item, a unique code, and indicates if the item is sold out.
Inventory: Contains an array of ItemShelf objects, allowing for item management.
VendingMachine: Holds the inventory and current state, providing methods to select items, insert payment, and dispense items.
Coin: An enum representing different coin denominations.
ItemType: An enum representing types of items available in the vending machine.
VendingMachineState: An interface for different states (Idle, Selection, Has Money, Dispense) of the vending machine.

Future improvements

Critically examine your design for any flaws or areas for future improvement...

In Future i want to add the

Notification to Admin

We will implement a Notification System to alert administrators in situations such as:

OUT_OF_ORDER status.
Multiple payment retry attempts.

Using the Observer Design Pattern, the vending machine will notify all registered observers when these events occur, enabling quick action via alerts (like email or SMS).

Bill Generation

We will introduce a Bill Generation feature that provides users with a receipt for their purchase, including:

Product details (type, code, price).
Transaction details (timestamp, payment method).
Change returned if applicable.

This enhances transparency and record-keeping for both users and administrators.