ATM System

Introduction

In this comprehensive case study, we’ll design an ATM (Automated Teller Machine) System from scratch using the systematic 8-step approach. This is a popular LLD interview problem that demonstrates state management, authentication, concurrent transaction handling, and multiple design patterns.

Why This Problem?

ATM System is perfect for learning LLD because it involves:

• State Management - ATM behavior changes based on authentication state
• Multiple Design Patterns - State Pattern, Chain of Responsibility, Singleton
• Concurrency - Thread-safe account operations, concurrent transaction handling
• Real-world Complexity - Authentication, cash dispensing, bank integration
• Clear Boundaries - Well-defined scope, easy to understand

---

Problem Statement

Design an ATM System that can:

• Allow users to perform basic banking transactions (check balance, withdraw cash, deposit cash)
• Authenticate users via card insertion and PIN entry
• Communicate with the bank’s main system to verify accounts and process transactions
• Dispense cash using multiple note denominations ($100, $50, $20)
• Handle concurrent transactions safely while maintaining data consistency
• Manage ATM states (idle, card inserted, authenticated) with clear transitions

---

Step 1: Clarify Requirements

Before designing, let’s ask the right questions!

Clarifying Questions

Functional Requirements:

1. Transaction Types: What operations should the ATM support? → Check balance, withdraw cash, deposit cash
2. Authentication: How should users authenticate? → Insert ATM card and enter PIN
3. Bank Integration: Should ATM operate independently? → No, must communicate with bank’s main system
4. Cash Dispensing: What denominations? → Multiple denominations ($100, $50, $20) using chain-based approach
5. Concurrency: How to handle multiple users? → Thread-safe operations at account level, even if one user per ATM physically

Non-Functional Requirements:

1. Concurrency: Multiple ATMs accessing same account → Thread-safe balance updates
2. State Management: Clear state transitions → Idle → Card Inserted → Authenticated → Idle
3. Extensibility: Easy to add transaction types → Modular design with interfaces
4. Security: Authentication before transactions → Card and PIN validation

Edge Cases to Consider:

• What if invalid card is inserted?
• What if incorrect PIN is entered?
• What if ATM doesn’t have enough cash?
• What if account has insufficient balance?
• What if multiple ATMs access same account simultaneously?
• What if cash dispenser cannot provide exact amount?

Requirements Summary

---

Step 2: Identify Actors

Actors are external entities that interact with the system.

Who Uses This System?

Primary Actors:

1. Customer/User - Inserts card, enters PIN, performs transactions
2. Bank Administrator - (Future) Manages accounts, monitors transactions
3. ATM Maintenance Staff - (Future) Refills cash, performs maintenance

Secondary Actors:

• Bank’s Main System - External system that manages accounts (represented by BankService)
• Payment Network - (Future) External payment processing

Actor Interactions

Actor vs Entity

Actors are external users/systems that interact with your system. Entities are internal objects managed by the system. In this case:

• Customer (Actor) uses ATMSystem (Entity)
• Card is an Entity, not an Actor (it’s data, not a user)
• BankService represents the bank’s backend system

---

Step 3: Identify Entities

Entities are core objects in your system that have data and behavior.

The Noun Hunt

Looking at the requirements, we identify these core entities:

1. ATMSystem - Main orchestrator, manages state and transactions
2. Card - Represents ATM card with card number and PIN
3. Account - Bank account with balance and linked cards
4. BankService - Bank’s backend system managing accounts and cards
5. CashDispenser - Handles physical cash dispensing
6. ATMState - Interface for ATM states (Idle, HasCard, Authenticated)
7. DispenseChain - Interface for cash dispensing chain
8. NoteDispenser - Handles specific denomination dispensing

Entity Relationships

---

Step 4: Assign Responsibilities

Each class should have a single, well-defined responsibility (SRP).

Responsibility Assignment

ATMSystem:

• Manage ATM state transitions
• Delegate operations to current state
• Coordinate transactions with bank service
• Track transaction counter

BankService:

• Manage cards and accounts
• Authenticate users (card + PIN)
• Process transactions (withdraw, deposit, balance check)
• Link cards to accounts

Account:

• Manage account balance
• Provide thread-safe withdraw/deposit operations
• Track linked cards

Card:

• Store card information (card number, PIN)
• Provide access to card data

CashDispenser:

• Check if cash can be dispensed
• Dispense cash using chain of responsibility
• Manage note dispenser chain

ATMState (IdleState, HasCardState, AuthenticatedState):

• Handle operations based on current state
• Validate state transitions
• Provide appropriate responses for invalid operations

NoteDispenser:

• Handle specific denomination dispensing
• Check if denomination can fulfill request
• Pass remaining amount to next chain link

Responsibility Visualization

[Single Responsibility Principle](/design-principles/solid-principles/00-single-responsibility-principle)

Each class should have one reason to change. For example:

• ATMSystem changes only when ATM orchestration logic changes
• Account changes only when balance management logic changes
• CashDispenser changes only when cash dispensing logic changes
• ATMState implementations change only when state behavior changes

---

Step 5: Design Class Diagrams

Class diagrams show structure, relationships, and design patterns.

Complete Class Diagram

classDiagram
    class ATMSystem {
        -ATMSystem INSTANCE
        -AtomicLong transactionCounter
        -ATMState currentState
        -Card currentCard
        -CashDispenser cashDispenser
        -BankService bankService
        +getInstance() ATMSystem
        +insertCard(String) void
        +enterPin(String) void
        +selectOperation(OperationType, int) void
        +ejectCard() void
        +checkBalance() void
        +withdrawCash(int) void
        +depositCash(int) void
        +changeState(ATMState) void
    }
    
    class BankService {
        -Map~String,Card~ cards
        -Map~Card,Account~ cardAccountMap
        -Map~String,Account~ accounts
        +createCard(String, String) Card
        +createAccount(String, double) Account
        +linkCardToAccount(Card, Account) void
        +getCard(String) Card
        +authenticate(Card, String) boolean
        +getBalance(Card) double
        +withdrawMoney(Card, double) boolean
        +depositMoney(Card, double) void
    }
    
    class Account {
        -String accountNumber
        -double balance
        -Map~String,Card~ cards
        +withdraw(double) boolean
        +deposit(double) void
        +getBalance() double
        +addCard(Card) void
    }
    
    class Card {
        -String cardNumber
        -String pin
        +getCardNumber() String
        +getPin() String
    }
    
    class CashDispenser {
        -DispenseChain chain
        +canDispenseCash(int) boolean
        +dispenseCash(int) void
    }
    
    class ATMState {
        <<interface>>
        +insertCard(ATMSystem, String) void
        +enterPin(ATMSystem, String) void
        +selectOperation(ATMSystem, OperationType, int) void
        +ejectCard(ATMSystem) void
    }
    
    class IdleState {
        +insertCard(ATMSystem, String) void
        +enterPin(ATMSystem, String) void
        +selectOperation(ATMSystem, OperationType, int) void
        +ejectCard(ATMSystem) void
    }
    
    class HasCardState {
        +insertCard(ATMSystem, String) void
        +enterPin(ATMSystem, String) void
        +selectOperation(ATMSystem, OperationType, int) void
        +ejectCard(ATMSystem) void
    }
    
    class AuthenticatedState {
        +insertCard(ATMSystem, String) void
        +enterPin(ATMSystem, String) void
        +selectOperation(ATMSystem, OperationType, int) void
        +ejectCard(ATMSystem) void
    }
    
    class DispenseChain {
        <<interface>>
        +dispense(int) void
        +setNextChain(DispenseChain) void
        +canDispense(int) boolean
    }
    
    class NoteDispenser {
        <<abstract>>
        -int noteValue
        -DispenseChain nextChain
        -int numNotes
        +dispense(int) void
        +canDispense(int) boolean
        +setNextChain(DispenseChain) void
    }
    
    class NoteDispenser100 {
        +NoteDispenser100(int)
    }
    
    class NoteDispenser50 {
        +NoteDispenser50(int)
    }
    
    class NoteDispenser20 {
        +NoteDispenser20(int)
    }
    
    class OperationType {
        <<enumeration>>
        WITHDRAW_CASH
        DEPOSIT_CASH
        CHECK_BALANCE
    }
    
    ATMSystem "1" *-- "1" ATMState : has
    ATMSystem "1" *-- "1" CashDispenser : has
    ATMSystem "1" o-- "1" BankService : uses
    ATMSystem --> OperationType : uses
    ATMSystem --> Card : references
    
    BankService "1" *-- "many" Account : manages
    BankService "1" *-- "many" Card : manages
    Account "1" *-- "many" Card : linked to
    
    CashDispenser --> DispenseChain : uses
    DispenseChain <|.. NoteDispenser
    NoteDispenser <|-- NoteDispenser100
    NoteDispenser <|-- NoteDispenser50
    NoteDispenser <|-- NoteDispenser20
    NoteDispenser --> DispenseChain : nextChain
    
    ATMState <|.. IdleState
    ATMState <|.. HasCardState
    ATMState <|.. AuthenticatedState

Design Patterns Used

1. State Pattern - ATMState and implementations

• Encapsulates ATM behavior based on current state
• Eliminates complex if-else chains
• Easy to add new states

2. Chain of Responsibility Pattern - DispenseChain and NoteDispenser

• Handles cash dispensing with multiple denominations
• Flexible fallback mechanism
• Easy to extend with new denominations

3. Singleton Pattern - ATMSystem

• Ensures single ATM instance per physical machine
• Prevents multiple instances causing inconsistencies

---

Step 6: Define Contracts & APIs

Contracts define how classes interact - method signatures, interfaces, and behavior.

Core Interfaces

Python

ATMState Interface:

patterns/state.py

class ATMState(ABC):
    """
    Interface for ATM states.
    Each state defines behavior for ATM operations.
    """
    @abstractmethod
    def insert_card(self, atm, card_number: str):
        """
        Handle card insertion.

        Args:
            atm: ATMSystem instance
            card_number: Card number to insert
        """
        pass

    @abstractmethod
    def enter_pin(self, atm, pin: str):
        """
        Handle PIN entry.

        Args:
            atm: ATMSystem instance
            pin: PIN entered by user
        """
        pass

    @abstractmethod
    def select_operation(self, atm, op: OperationType, amount: int):
        """
        Handle operation selection.

        Args:
            atm: ATMSystem instance
            op: Operation type (WITHDRAW_CASH, DEPOSIT_CASH, CHECK_BALANCE)
            amount: Amount for transaction (0 for balance check)
        """
        pass

    @abstractmethod
    def eject_card(self, atm):
        """
        Handle card ejection.

        Args:
            atm: ATMSystem instance
        """
        pass

DispenseChain Interface:

class DispenseChain(ABC):
    """
    Interface for cash dispensing chain.
    Each handler processes request or passes to next.
    """
    @abstractmethod
    def dispense(self, amount: int):
        """
        Dispense cash amount.

        Args:
            amount: Amount to dispense
        """
        pass

    @abstractmethod
    def set_next_chain(self, next_chain: DispenseChain):
        """
        Set next chain handler.

        Args:
            next_chain: Next handler in chain
        """
        pass

    @abstractmethod
    def can_dispense(self, amount: int) -> bool:
        """
        Check if amount can be dispensed.

        Args:
            amount: Amount to check

        Returns:
            bool: True if can dispense, False otherwise
        """
        pass

Java

ATMState Interface:

patterns/state.java

interface ATMState {
    /**
     * Handle card insertion.
     * @param atm ATMSystem instance
     * @param cardNumber Card number to insert
     */
    void insertCard(ATMSystem atm, String cardNumber);

    /**
     * Handle PIN entry.
     * @param atm ATMSystem instance
     * @param pin PIN entered by user
     */
    void enterPin(ATMSystem atm, String pin);

    /**
     * Handle operation selection.
     * @param atm ATMSystem instance
     * @param op Operation type (WITHDRAW_CASH, DEPOSIT_CASH, CHECK_BALANCE)
     * @param amount Amount for transaction (0 for balance check)
     */
    void selectOperation(ATMSystem atm, OperationType op, int amount);

    /**
     * Handle card ejection.
     * @param atm ATMSystem instance
     */
    void ejectCard(ATMSystem atm);
}

DispenseChain Interface:

interface DispenseChain {
    /**
     * Dispense cash amount.
     * @param amount Amount to dispense
     */
    void dispense(int amount);

    /**
     * Set next chain handler.
     * @param next Next handler in chain
     */
    void setNextChain(DispenseChain next);

    /**
     * Check if amount can be dispensed.
     * @param amount Amount to check
     * @return True if can dispense, False otherwise
     */
    boolean canDispense(int amount);
}

Core Class Contracts

Python

ATMSystem:

system/atm_system.py

class ATMSystem:
    @classmethod
    def get_instance(cls) -> 'ATMSystem':
        """
        Get singleton instance of ATM system.

        Returns:
            ATMSystem: The single instance
        """
        pass

    def insert_card(self, card_number: str) -> None:
        """
        Insert ATM card.

        Args:
            card_number: Card number to insert

        Raises:
            InvalidCardException: If card is invalid
        """
        pass

    def enter_pin(self, pin: str) -> None:
        """
        Enter PIN for authentication.

        Args:
            pin: PIN entered by user
        """
        pass

    def select_operation(self, op: OperationType, amount: int) -> None:
        """
        Select transaction operation.

        Args:
            op: Operation type
            amount: Amount for transaction (0 for balance check)
        """
        pass

    def withdraw_cash(self, amount: int) -> None:
        """
        Withdraw cash from account.

        Args:
            amount: Amount to withdraw

        Raises:
            InsufficientBalanceException: If account has insufficient balance
            InsufficientCashException: If ATM doesn't have enough cash
        """
        pass

    def deposit_cash(self, amount: int) -> None:
        """
        Deposit cash to account.

        Args:
            amount: Amount to deposit
        """
        pass

    def check_balance(self) -> None:
        """
        Check account balance.
        """
        pass

    def eject_card(self) -> None:
        """
        Eject ATM card.
        """
        pass

Account:

class Account:
    def withdraw(self, amount: float) -> bool:
        """
        Withdraw amount from account (thread-safe).

        Args:
            amount: Amount to withdraw

        Returns:
            bool: True if successful, False if insufficient balance
        """
        pass

    def deposit(self, amount: float) -> None:
        """
        Deposit amount to account (thread-safe).

        Args:
            amount: Amount to deposit
        """
        pass

    def get_balance(self) -> float:
        """
        Get current account balance (thread-safe).

        Returns:
            float: Current balance
        """
        pass

Java

ATMSystem:

system/atm_system.java

class ATMSystem {
    /**
     * Get singleton instance of ATM system.
     * @return The single instance
     */
    public static ATMSystem getInstance();

    /**
     * Insert ATM card.
     * @param cardNumber Card number to insert
     * @throws InvalidCardException If card is invalid
     */
    public void insertCard(String cardNumber);

    /**
     * Enter PIN for authentication.
     * @param pin PIN entered by user
     */
    public void enterPin(String pin);

    /**
     * Select transaction operation.
     * @param op Operation type
     * @param amount Amount for transaction (0 for balance check)
     */
    public void selectOperation(OperationType op, int amount);

    /**
     * Withdraw cash from account.
     * @param amount Amount to withdraw
     * @throws InsufficientBalanceException If account has insufficient balance
     * @throws InsufficientCashException If ATM doesn't have enough cash
     */
    public void withdrawCash(int amount);

    /**
     * Deposit cash to account.
     * @param amount Amount to deposit
     */
    public void depositCash(int amount);

    /**
     * Check account balance.
     */
    public void checkBalance();

    /**
     * Eject ATM card.
     */
    public void ejectCard();
}

Account:

class Account {
    /**
     * Withdraw amount from account (thread-safe).
     * @param amount Amount to withdraw
     * @return True if successful, False if insufficient balance
     */
    public synchronized boolean withdraw(double amount);

    /**
     * Deposit amount to account (thread-safe).
     * @param amount Amount to deposit
     */
    public synchronized void deposit(double amount);

    /**
     * Get current account balance (thread-safe).
     * @return Current balance
     */
    public synchronized double getBalance();
}

Contract Visualization

Contract [Design Principles](/design-principles/00-introduction-to-design-principles)

• Be explicit - Clear parameter types and return types
• Document exceptions - What can go wrong?
• Keep it simple - Don’t over-complicate
• Think about callers - What do they need?
• Thread safety - Document thread-safe operations

---

Step 7: Handle Edge Cases

Edge cases are scenarios that might not be obvious but are important to handle.

Critical Edge Cases

1. Invalid Card

• Validate card exists in bank system
• Return appropriate error message
• Stay in IdleState

2. Incorrect PIN

• Validate PIN matches card’s PIN
• Allow retry (stay in HasCardState)
• Don’t block card (in basic version)

3. Insufficient Account Balance

• Check balance before withdrawal
• Return error message
• Don’t dispense cash if insufficient

4. Insufficient ATM Cash

• Check if ATM can dispense requested amount
• Validate before account withdrawal
• Return error if cannot fulfill

5. Concurrent Access

• Multiple ATMs accessing same account
• Race condition on balance updates
• Solution: Synchronized methods in Account

6. Cash Dispensing Failure

• What if exact amount cannot be dispensed?
• Check availability before dispensing
• Return error if cannot fulfill

7. Invalid State Transitions

• Operations in wrong state (e.g., withdraw in IdleState)
• Each state validates operations
• Return appropriate error messages

Edge Case Handling Flow

Thread Safety Considerations

Python

thread_safe_account.py

# Thread-safe account operations
class Account:
    def __init__(self, account_number: str, initial_balance: float):
        self.account_number = account_number
        self.balance = initial_balance
        self.lock = Lock()  # Thread-safe lock

    def withdraw(self, amount: float) -> bool:
        with self.lock:  # Critical section
            if self.balance >= amount:
                self.balance -= amount
                return True
            return False

    def deposit(self, amount: float):
        with self.lock:  # Critical section
            self.balance += amount

    def get_balance(self) -> float:
        with self.lock:  # Critical section
            return self.balance

Java

ThreadSafeAccount.java

// Thread-safe account operations
class Account {
    private double balance;
    private final Object lock = new Object();

    public boolean withdraw(double amount) {
        synchronized (lock) {  // Critical section
            if (balance >= amount) {
                balance -= amount;
                return true;
            }
            return false;
        }
    }

    public void deposit(double amount) {
        synchronized (lock) {  // Critical section
            balance += amount;
        }
    }

    public double getBalance() {
        synchronized (lock) {  // Critical section
            return balance;
        }
    }
}

Edge Case Checklist

Always think about:

• What if input is null/empty?
• What if authentication fails?
• What if account has insufficient balance?
• What if ATM doesn’t have cash?
• What if multiple users access same account?
• What if invalid state transition?
• What if concurrent access?

---

Step 8: Code Implementation

Finally, implement your design following SOLID principles and design patterns.

Complete Implementation

Python

atm_complete.py

from enum import Enum
from abc import ABC, abstractmethod
from threading import Lock
from typing import Optional, Dict
import uuid

# =====================
# ENUMERATION
# =====================

class OperationType(Enum):
    WITHDRAW_CASH = "WITHDRAW_CASH"
    DEPOSIT_CASH = "DEPOSIT_CASH"
    CHECK_BALANCE = "CHECK_BALANCE"

# =====================
# MODELS
# =====================

class Card:
    def __init__(self, card_number: str, pin: str):
        self.card_number = card_number
        self.pin = pin

    def get_card_number(self) -> str:
        return self.card_number

    def get_pin(self) -> str:
        return self.pin

class Account:
    def __init__(self, account_number: str, initial_balance: float):
        self.account_number = account_number
        self.balance = initial_balance
        self.cards: Dict[str, Card] = {}
        self.lock = Lock()

    def withdraw(self, amount: float) -> bool:
        with self.lock:
            if self.balance >= amount:
                self.balance -= amount
                return True
            return False

    def deposit(self, amount: float):
        with self.lock:
            self.balance += amount

    def get_balance(self) -> float:
        with self.lock:
            return self.balance

    def get_account_number(self) -> str:
        return self.account_number

    def add_card(self, card: Card):
        self.cards[card.get_card_number()] = card

# =====================
# SERVICES
# =====================

class BankService:
    def __init__(self):
        self.cards: Dict[str, Card] = {}
        self.card_account_map: Dict[Card, Account] = {}
        self.accounts: Dict[str, Account] = {}

    def create_card(self, card_number: str, pin: str) -> Card:
        card = Card(card_number, pin)
        self.cards[card_number] = card
        return card

    def create_account(self, account_number: str, initial_balance: float) -> Account:
        account = Account(account_number, initial_balance)
        self.accounts[account_number] = account
        return account

    def link_card_to_account(self, card: Card, account: Account):
        self.card_account_map[card] = account
        account.add_card(card)

    def get_card(self, card_number: str) -> Optional[Card]:
        return self.cards.get(card_number)

    def authenticate(self, card: Card, pin: str) -> bool:
        return card is not None and card.get_pin() == pin

    def get_balance(self, card: Card) -> float:
        account = self.card_account_map.get(card)
        return account.get_balance() if account else 0.0

    def withdraw_money(self, card: Card, amount: float) -> bool:
        account = self.card_account_map.get(card)
        return account.withdraw(amount) if account else False

    def deposit_money(self, card: Card, amount: float):
        account = self.card_account_map.get(card)
        if account:
            account.deposit(amount)

# =====================
# STATE PATTERN
# =====================

class ATMState(ABC):
    @abstractmethod
    def insert_card(self, atm, card_number: str):
        pass

    @abstractmethod
    def enter_pin(self, atm, pin: str):
        pass

    @abstractmethod
    def select_operation(self, atm, op: OperationType, amount: int):
        pass

    @abstractmethod
    def eject_card(self, atm):
        pass

class IdleState(ATMState):
    def insert_card(self, atm, card_number: str):
        card = atm.get_bank_service().get_card(card_number)
        if card:
            atm.set_current_card(card)
            atm.change_state(HasCardState())
            print("Card inserted. Please enter PIN.")
        else:
            print("Invalid card.")

    def enter_pin(self, atm, pin: str):
        print("Please insert card first.")

    def select_operation(self, atm, op: OperationType, amount: int):
        print("Please insert card and authenticate first.")

    def eject_card(self, atm):
        print("No card to eject.")

class HasCardState(ATMState):
    def insert_card(self, atm, card_number: str):
        print("Card already inserted. Please enter PIN or eject card.")

    def enter_pin(self, atm, pin: str):
        if atm.authenticate(pin):
            atm.change_state(AuthenticatedState())
            print("Authentication successful. Please select operation.")
        else:
            print("Invalid PIN. Please try again.")

    def select_operation(self, atm, op: OperationType, amount: int):
        print("Please enter PIN first.")

    def eject_card(self, atm):
        atm.set_current_card(None)
        atm.change_state(IdleState())
        print("Card ejected.")

class AuthenticatedState(ATMState):
    def insert_card(self, atm, card_number: str):
        print("Card already inserted and authenticated.")

    def enter_pin(self, atm, pin: str):
        print("Already authenticated. Please select operation.")

    def select_operation(self, atm, op: OperationType, amount: int):
        if op == OperationType.CHECK_BALANCE:
            atm.check_balance()
        elif op == OperationType.WITHDRAW_CASH:
            atm.withdraw_cash(amount)
        elif op == OperationType.DEPOSIT_CASH:
            atm.deposit_cash(amount)

    def eject_card(self, atm):
        atm.set_current_card(None)
        atm.change_state(IdleState())
        print("Card ejected. Thank you!")

# =====================
# CHAIN OF RESPONSIBILITY
# =====================

class DispenseChain(ABC):
    @abstractmethod
    def dispense(self, amount: int):
        pass

    @abstractmethod
    def set_next_chain(self, next_chain):
        pass

    @abstractmethod
    def can_dispense(self, amount: int) -> bool:
        pass

class NoteDispenser(DispenseChain):
    def __init__(self, note_value: int, num_notes: int):
        self.note_value = note_value
        self.num_notes = num_notes
        self.next_chain: Optional[DispenseChain] = None

    def set_next_chain(self, next_chain: DispenseChain):
        self.next_chain = next_chain

    def dispense(self, amount: int):
        if amount >= self.note_value and self.num_notes > 0:
            notes_needed = min(amount // self.note_value, self.num_notes)
            dispensed_amount = notes_needed * self.note_value
            self.num_notes -= notes_needed
            print(f"Dispensing {notes_needed} notes of ${self.note_value}")

            remaining = amount - dispensed_amount
            if remaining > 0 and self.next_chain:
                self.next_chain.dispense(remaining)
        elif self.next_chain:
            self.next_chain.dispense(amount)
        elif amount > 0:
            print(f"Cannot dispense remaining amount: ${amount}")

    def can_dispense(self, amount: int) -> bool:
        if amount >= self.note_value and self.num_notes > 0:
            notes_needed = min(amount // self.note_value, self.num_notes)
            remaining = amount - (notes_needed * self.note_value)
            if remaining == 0:
                return True
            if self.next_chain:
                return self.next_chain.can_dispense(remaining)
            return False
        if self.next_chain:
            return self.next_chain.can_dispense(amount)
        return False

class NoteDispenser100(NoteDispenser):
    def __init__(self, num_notes: int):
        super().__init__(100, num_notes)

class NoteDispenser50(NoteDispenser):
    def __init__(self, num_notes: int):
        super().__init__(50, num_notes)

class NoteDispenser20(NoteDispenser):
    def __init__(self, num_notes: int):
        super().__init__(20, num_notes)

class CashDispenser:
    def __init__(self):
        dispenser100 = NoteDispenser100(10)
        dispenser50 = NoteDispenser50(20)
        dispenser20 = NoteDispenser20(30)

        dispenser100.set_next_chain(dispenser50)
        dispenser50.set_next_chain(dispenser20)
        self.chain = dispenser100

    def can_dispense_cash(self, amount: int) -> bool:
        return self.chain.can_dispense(amount)

    def dispense_cash(self, amount: int):
        if self.can_dispense_cash(amount):
            self.chain.dispense(amount)
        else:
            print(f"Cannot dispense ${amount}. Insufficient cash in ATM.")

# =====================
# SINGLETON - MAIN SYSTEM
# =====================

class ATMSystem:
    _instance = None
    _lock = Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        if hasattr(self, '_initialized'):
            return
        self.transaction_counter = 0
        self.transaction_lock = Lock()
        self.current_state: ATMState = IdleState()
        self.current_card: Optional[Card] = None
        self.cash_dispenser = CashDispenser()
        self.bank_service = BankService()
        self._initialized = True

    @classmethod
    def get_instance(cls):
        return cls()

    def insert_card(self, card_number: str):
        self.current_state.insert_card(self, card_number)

    def enter_pin(self, pin: str):
        self.current_state.enter_pin(self, pin)

    def select_operation(self, op: OperationType, amount: int):
        self.current_state.select_operation(self, op, amount)

    def eject_card(self):
        self.current_state.eject_card(self)

    def change_state(self, state: ATMState):
        self.current_state = state

    def set_current_card(self, card: Optional[Card]):
        self.current_card = card

    def get_current_card(self) -> Optional[Card]:
        return self.current_card

    def authenticate(self, pin: str) -> bool:
        if self.current_card:
            return self.bank_service.authenticate(self.current_card, pin)
        return False

    def check_balance(self):
        if self.current_card:
            balance = self.bank_service.get_balance(self.current_card)
            print(f"Your account balance is: ${balance}")
            with self.transaction_lock:
                self.transaction_counter += 1

    def withdraw_cash(self, amount: int):
        if not self.current_card:
            print("Please authenticate first.")
            return

        if not self.cash_dispenser.can_dispense_cash(amount):
            print(f"ATM does not have enough cash to dispense ${amount}")
            return

        if self.bank_service.withdraw_money(self.current_card, amount):
            self.cash_dispenser.dispense_cash(amount)
            print("Transaction successful. Please take your cash.")
            with self.transaction_lock:
                self.transaction_counter += 1
        else:
            print("Insufficient balance in your account.")

    def deposit_cash(self, amount: int):
        if not self.current_card:
            print("Please authenticate first.")
            return

        self.bank_service.deposit_money(self.current_card, amount)
        print(f"Deposit successful. ${amount} deposited to your account.")
        with self.transaction_lock:
            self.transaction_counter += 1

    def get_bank_service(self) -> BankService:
        return self.bank_service

    def get_transaction_count(self) -> int:
        with self.transaction_lock:
            return self.transaction_counter

# =====================
# DEMO
# =====================

if __name__ == "__main__":
    atm = ATMSystem.get_instance()
    bank_service = atm.get_bank_service()

    account = bank_service.create_account("ACC001", 1000.0)
    card = bank_service.create_card("CARD001", "1234")
    bank_service.link_card_to_account(card, account)

    print("=== ATM Transaction Flow ===")
    atm.insert_card("CARD001")
    atm.enter_pin("1234")
    atm.select_operation(OperationType.CHECK_BALANCE, 0)
    atm.select_operation(OperationType.WITHDRAW_CASH, 150)
    atm.select_operation(OperationType.DEPOSIT_CASH, 50)
    atm.select_operation(OperationType.CHECK_BALANCE, 0)
    atm.eject_card()

    print(f"\nTotal transactions processed: {atm.get_transaction_count()}")

Java

ATMComplete.java

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

// =====================
// ENUMERATION
// =====================

enum OperationType {
    WITHDRAW_CASH,
    DEPOSIT_CASH,
    CHECK_BALANCE
}

// =====================
// MODELS
// =====================

class Card {
    private String cardNumber;
    private String pin;

    public Card(String cardNumber, String pin) {
        this.cardNumber = cardNumber;
        this.pin = pin;
    }

    public String getCardNumber() { return cardNumber; }
    public String getPin() { return pin; }
}

class Account {
    private String accountNumber;
    private double balance;
    private Map<String, Card> cards;

    public Account(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
        this.cards = new HashMap<>();
    }

    public synchronized boolean withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    public synchronized void deposit(double amount) {
        balance += amount;
    }

    public synchronized double getBalance() { return balance; }
    public String getAccountNumber() { return accountNumber; }
    public void addCard(Card card) { cards.put(card.getCardNumber(), card); }
}

// =====================
// SERVICES
// =====================

class BankService {
    private Map<String, Card> cards;
    private Map<Card, Account> cardAccountMap;
    private Map<String, Account> accounts;

    public BankService() {
        this.cards = new ConcurrentHashMap<>();
        this.cardAccountMap = new ConcurrentHashMap<>();
        this.accounts = new ConcurrentHashMap<>();
    }

    public Card createCard(String cardNumber, String pin) {
        Card card = new Card(cardNumber, pin);
        cards.put(cardNumber, card);
        return card;
    }

    public Account createAccount(String accountNumber, double initialBalance) {
        Account account = new Account(accountNumber, initialBalance);
        accounts.put(accountNumber, account);
        return account;
    }

    public void linkCardToAccount(Card card, Account account) {
        cardAccountMap.put(card, account);
        account.addCard(card);
    }

    public Card getCard(String cardNumber) {
        return cards.get(cardNumber);
    }

    public boolean authenticate(Card card, String pin) {
        return card != null && card.getPin().equals(pin);
    }

    public double getBalance(Card card) {
        Account account = cardAccountMap.get(card);
        return account != null ? account.getBalance() : 0.0;
    }

    public boolean withdrawMoney(Card card, double amount) {
        Account account = cardAccountMap.get(card);
        if (account != null) {
            return account.withdraw(amount);
        }
        return false;
    }

    public void depositMoney(Card card, double amount) {
        Account account = cardAccountMap.get(card);
        if (account != null) {
            account.deposit(amount);
        }
    }
}

// =====================
// STATE PATTERN
// =====================

interface ATMState {
    void insertCard(ATMSystem atm, String cardNumber);
    void enterPin(ATMSystem atm, String pin);
    void selectOperation(ATMSystem atm, OperationType op, int amount);
    void ejectCard(ATMSystem atm);
}

class IdleState implements ATMState {
    @Override
    public void insertCard(ATMSystem atm, String cardNumber) {
        Card card = atm.getBankService().getCard(cardNumber);
        if (card != null) {
            atm.setCurrentCard(card);
            atm.changeState(new HasCardState());
            System.out.println("Card inserted. Please enter PIN.");
        } else {
            System.out.println("Invalid card.");
        }
    }

    @Override
    public void enterPin(ATMSystem atm, String pin) {
        System.out.println("Please insert card first.");
    }

    @Override
    public void selectOperation(ATMSystem atm, OperationType op, int amount) {
        System.out.println("Please insert card and authenticate first.");
    }

    @Override
    public void ejectCard(ATMSystem atm) {
        System.out.println("No card to eject.");
    }
}

class HasCardState implements ATMState {
    @Override
    public void insertCard(ATMSystem atm, String cardNumber) {
        System.out.println("Card already inserted. Please enter PIN or eject card.");
    }

    @Override
    public void enterPin(ATMSystem atm, String pin) {
        if (atm.authenticate(pin)) {
            atm.changeState(new AuthenticatedState());
            System.out.println("Authentication successful. Please select operation.");
        } else {
            System.out.println("Invalid PIN. Please try again.");
        }
    }

    @Override
    public void selectOperation(ATMSystem atm, OperationType op, int amount) {
        System.out.println("Please enter PIN first.");
    }

    @Override
    public void ejectCard(ATMSystem atm) {
        atm.setCurrentCard(null);
        atm.changeState(new IdleState());
        System.out.println("Card ejected.");
    }
}

class AuthenticatedState implements ATMState {
    @Override
    public void insertCard(ATMSystem atm, String cardNumber) {
        System.out.println("Card already inserted and authenticated.");
    }

    @Override
    public void enterPin(ATMSystem atm, String pin) {
        System.out.println("Already authenticated. Please select operation.");
    }

    @Override
    public void selectOperation(ATMSystem atm, OperationType op, int amount) {
        switch (op) {
            case CHECK_BALANCE:
                atm.checkBalance();
                break;
            case WITHDRAW_CASH:
                atm.withdrawCash(amount);
                break;
            case DEPOSIT_CASH:
                atm.depositCash(amount);
                break;
        }
    }

    @Override
    public void ejectCard(ATMSystem atm) {
        atm.setCurrentCard(null);
        atm.changeState(new IdleState());
        System.out.println("Card ejected. Thank you!");
    }
}

// =====================
// CHAIN OF RESPONSIBILITY
// =====================

interface DispenseChain {
    void dispense(int amount);
    void setNextChain(DispenseChain next);
    boolean canDispense(int amount);
}

abstract class NoteDispenser implements DispenseChain {
    protected int noteValue;
    protected DispenseChain nextChain;
    protected int numNotes;

    public NoteDispenser(int noteValue, int numNotes) {
        this.noteValue = noteValue;
        this.numNotes = numNotes;
    }

    @Override
    public void setNextChain(DispenseChain next) {
        this.nextChain = next;
    }

    @Override
    public void dispense(int amount) {
        if (amount >= noteValue && numNotes > 0) {
            int notesNeeded = Math.min(amount / noteValue, numNotes);
            int dispensedAmount = notesNeeded * noteValue;
            numNotes -= notesNeeded;
            System.out.println("Dispensing " + notesNeeded + " notes of $" + noteValue);

            int remaining = amount - dispensedAmount;
            if (remaining > 0 && nextChain != null) {
                nextChain.dispense(remaining);
            }
        } else if (nextChain != null) {
            nextChain.dispense(amount);
        } else if (amount > 0) {
            System.out.println("Cannot dispense remaining amount: $" + amount);
        }
    }

    @Override
    public boolean canDispense(int amount) {
        if (amount >= noteValue && numNotes > 0) {
            int notesNeeded = Math.min(amount / noteValue, numNotes);
            int remaining = amount - (notesNeeded * noteValue);
            if (remaining == 0) return true;
            if (nextChain != null) return nextChain.canDispense(remaining);
            return false;
        }
        if (nextChain != null) return nextChain.canDispense(amount);
        return false;
    }
}

class NoteDispenser100 extends NoteDispenser {
    public NoteDispenser100(int numNotes) {
        super(100, numNotes);
    }
}

class NoteDispenser50 extends NoteDispenser {
    public NoteDispenser50(int numNotes) {
        super(50, numNotes);
    }
}

class NoteDispenser20 extends NoteDispenser {
    public NoteDispenser20(int numNotes) {
        super(20, numNotes);
    }
}

class CashDispenser {
    private DispenseChain chain;

    public CashDispenser() {
        NoteDispenser100 dispenser100 = new NoteDispenser100(10);
        NoteDispenser50 dispenser50 = new NoteDispenser50(20);
        NoteDispenser20 dispenser20 = new NoteDispenser20(30);

        dispenser100.setNextChain(dispenser50);
        dispenser50.setNextChain(dispenser20);
        this.chain = dispenser100;
    }

    public boolean canDispenseCash(int amount) {
        return chain.canDispense(amount);
    }

    public void dispenseCash(int amount) {
        if (canDispenseCash(amount)) {
            chain.dispense(amount);
        } else {
            System.out.println("Cannot dispense $" + amount + ". Insufficient cash in ATM.");
        }
    }
}

// =====================
// SINGLETON - MAIN SYSTEM
// =====================

class ATMSystem {
    private static ATMSystem INSTANCE;
    private AtomicLong transactionCounter;
    private ATMState currentState;
    private Card currentCard;
    private CashDispenser cashDispenser;
    private BankService bankService;

    private ATMSystem() {
        this.transactionCounter = new AtomicLong(0);
        this.currentState = new IdleState();
        this.cashDispenser = new CashDispenser();
        this.bankService = new BankService();
    }

    public static synchronized ATMSystem getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new ATMSystem();
        }
        return INSTANCE;
    }

    public void insertCard(String cardNumber) {
        currentState.insertCard(this, cardNumber);
    }

    public void enterPin(String pin) {
        currentState.enterPin(this, pin);
    }

    public void selectOperation(OperationType op, int amount) {
        currentState.selectOperation(this, op, amount);
    }

    public void ejectCard() {
        currentState.ejectCard(this);
    }

    public void changeState(ATMState state) {
        this.currentState = state;
    }

    public void setCurrentCard(Card card) {
        this.currentCard = card;
    }

    public Card getCurrentCard() {
        return currentCard;
    }

    public boolean authenticate(String pin) {
        if (currentCard != null) {
            return bankService.authenticate(currentCard, pin);
        }
        return false;
    }

    public void checkBalance() {
        if (currentCard != null) {
            double balance = bankService.getBalance(currentCard);
            System.out.println("Your account balance is: $" + balance);
            transactionCounter.incrementAndGet();
        }
    }

    public void withdrawCash(int amount) {
        if (currentCard == null) {
            System.out.println("Please authenticate first.");
            return;
        }

        if (!cashDispenser.canDispenseCash(amount)) {
            System.out.println("ATM does not have enough cash to dispense $" + amount);
            return;
        }

        if (bankService.withdrawMoney(currentCard, amount)) {
            cashDispenser.dispenseCash(amount);
            System.out.println("Transaction successful. Please take your cash.");
            transactionCounter.incrementAndGet();
        } else {
            System.out.println("Insufficient balance in your account.");
        }
    }

    public void depositCash(int amount) {
        if (currentCard == null) {
            System.out.println("Please authenticate first.");
            return;
        }

        bankService.depositMoney(currentCard, amount);
        System.out.println("Deposit successful. $" + amount + " deposited to your account.");
        transactionCounter.incrementAndGet();
    }

    public BankService getBankService() {
        return bankService;
    }

    public long getTransactionCount() {
        return transactionCounter.get();
    }
}

// =====================
// DEMO
// =====================

class ATMDemo {
    public static void main(String[] args) {
        ATMSystem atm = ATMSystem.getInstance();
        BankService bankService = atm.getBankService();

        Account account = bankService.createAccount("ACC001", 1000.0);
        Card card = bankService.createCard("CARD001", "1234");
        bankService.linkCardToAccount(card, account);

        System.out.println("=== ATM Transaction Flow ===");
        atm.insertCard("CARD001");
        atm.enterPin("1234");
        atm.selectOperation(OperationType.CHECK_BALANCE, 0);
        atm.selectOperation(OperationType.WITHDRAW_CASH, 150);
        atm.selectOperation(OperationType.DEPOSIT_CASH, 50);
        atm.selectOperation(OperationType.CHECK_BALANCE, 0);
        atm.ejectCard();

        System.out.println("\nTotal transactions processed: " + atm.getTransactionCount());
    }
}

Key Implementation Highlights

1. State Pattern:

• IdleState, HasCardState, AuthenticatedState encapsulate behavior
• Clear state transitions
• No complex if-else chains

2. Chain of Responsibility Pattern:

• NoteDispenser100, NoteDispenser50, NoteDispenser20 handle denominations
• Flexible fallback mechanism
• Easy to extend with new denominations

3. Thread Safety:

• synchronized methods in Account (Java)
• Lock in Account (Python)
• ConcurrentHashMap in BankService
• AtomicLong for transaction counter

4. Singleton Pattern:

• Single ATM instance per physical machine
• Thread-safe initialization

---

Design Patterns Deep Dive

Why State Pattern?

Problem: Without State Pattern, ATMSystem methods would look like:

void insertCard(String cardNumber) {
    if (state == IDLE) {
        // insert card logic
    } else if (state == HAS_CARD) {
        System.out.println("Card already inserted");
    } else if (state == AUTHENTICATED) {
        System.out.println("Already authenticated");
    }
}

Why State Pattern?

• Eliminates if-else chains: Each state encapsulates its own behavior
• Open/Closed Principle: Add new states without modifying ATMSystem
• Single Responsibility: Each state class handles one behavior
• Easier to test: Test each state independently
• Clear state transitions: States explicitly define valid transitions

stateDiagram-v2
    [*] --> IdleState
    IdleState --> HasCardState: insertCard()
    HasCardState --> AuthenticatedState: enterPin() valid
    HasCardState --> IdleState: ejectCard()
    AuthenticatedState --> IdleState: ejectCard()
    AuthenticatedState --> AuthenticatedState: selectOperation()
    
    note right of IdleState
        No card inserted
        Can insert card
    end note
    
    note right of HasCardState
        Card inserted
        Can enter PIN
        Can eject card
    end note
    
    note right of AuthenticatedState
        PIN verified
        Can perform transactions
        Can eject card
    end note

Why Chain of Responsibility Pattern?

Problem: How should ATM dispense cash using different note denominations?

• If user requests $150, should it use: 1×$100 + 1×$50, or 3×$50, or 7×$20 + 1×$10?
• What if $100 notes are out? Fall back to $50 notes.
• What if ATM doesn’t have exact combination?

Why Chain of Responsibility Pattern?

• Flexible Dispensing: Each dispenser handles one denomination
• Fallback Mechanism: If one denomination can’t fulfill, try next
• Easy to Extend: Add new denominations without changing existing code
• Separation of Concerns: Each dispenser only knows about its denomination

sequenceDiagram
    participant ATM
    participant Chain as CashDispenser Chain
    participant D100 as $100 Dispenser
    participant D50 as $50 Dispenser
    participant D20 as $20 Dispenser
    
    ATM->>Chain: dispenseCash(150)
    Chain->>D100: Can dispense $100?
    D100->>D100: Dispense 1×$100
    D100->>D50: Remaining: $50
    D50->>D50: Dispense 1×$50
    D50-->>Chain: Success! Remaining: $0
    Chain-->>ATM: Cash dispensed

How it works:

• Chain starts with highest denomination ($100)
• Each NoteDispenser tries to fulfill as much as possible with its denomination
• Remaining amount is passed to next chain link
• If chain completes and amount is 0, dispensing succeeds
• If amount remains and no more links, dispensing fails

Why Singleton Pattern?

Problem: Multiple gates need to see the same ATM state.

Without Singleton:

// Gate A
ATMSystem atmA = new ATMSystem(); // Different instance
atmA.insertCard("CARD001");

// Gate B (different instance!)
ATMSystem atmB = new ATMSystem(); // Different instance
atmA.insertCard("CARD001"); // State inconsistency!

With Singleton:

// Gate A
ATMSystem atmA = ATMSystem.getInstance(); // Same instance
atmA.insertCard("CARD001");

// Gate B
ATMSystem atmB = ATMSystem.getInstance(); // Same instance!
// Both see same state

---

System Flow Diagrams

Authentication Flow

sequenceDiagram
    participant User
    participant ATM as ATMSystem
    participant Bank as BankService
    
    User->>ATM: Insert card
    ATM->>Bank: Validate card exists
    Bank-->>ATM: Card valid
    ATM->>ATM: Transition to HasCardState
    User->>ATM: Enter PIN
    ATM->>Bank: authenticate(card, PIN)
    alt PIN correct
        Bank-->>ATM: Authentication success
        ATM->>ATM: Transition to AuthenticatedState
    else PIN incorrect
        Bank-->>ATM: Authentication failed
        ATM->>ATM: Stay in HasCardState
    end

Withdrawal Flow

flowchart TD
    A[User: Withdraw $100] --> B[Check Authenticated]
    B -->|Yes| C[Check Cash Available]
    B -->|No| D[Error: Not authenticated]
    C -->|Yes| E[Check Account Balance]
    C -->|No| F[Error: Insufficient cash]
    E -->|Sufficient| G[Dispense Cash]
    E -->|Insufficient| H[Error: Insufficient balance]
    G --> I[Deduct from Account]
    I --> J[Transaction Complete]
    
    style D fill:#ef4444
    style F fill:#ef4444
    style H fill:#ef4444
    style J fill:#10b981

Cash Dispensing Flow

---

Extensibility & Future Enhancements

Easy to Extend

1. Add New State:

Python

new_state.py

class MaintenanceState(ATMState):
    """ATM is under maintenance."""

    def insert_card(self, atm, card_number: str):
        print("ATM is under maintenance. Please try later.")

    def enter_pin(self, atm, pin: str):
        print("ATM is under maintenance.")

    def select_operation(self, atm, op: OperationType, amount: int):
        print("ATM is under maintenance.")

    def eject_card(self, atm):
        print("ATM is under maintenance.")

Java

NewState.java

class MaintenanceState implements ATMState {
    /** ATM is under maintenance. */

    @Override
    public void insertCard(ATMSystem atm, String cardNumber) {
        System.out.println("ATM is under maintenance. Please try later.");
    }

    @Override
    public void enterPin(ATMSystem atm, String pin) {
        System.out.println("ATM is under maintenance.");
    }

    @Override
    public void selectOperation(ATMSystem atm, OperationType op, int amount) {
        System.out.println("ATM is under maintenance.");
    }

    @Override
    public void ejectCard(ATMSystem atm) {
        System.out.println("ATM is under maintenance.");
    }
}

2. Add New Denomination:

Python

new_denomination.py

class NoteDispenser10(NoteDispenser):
    def __init__(self, num_notes: int):
        super().__init__(10, num_notes)

# Update CashDispenser
class CashDispenser:
    def __init__(self):
        dispenser100 = NoteDispenser100(10)
        dispenser50 = NoteDispenser50(20)
        dispenser20 = NoteDispenser20(30)
        dispenser10 = NoteDispenser10(40)  # New!

        dispenser100.set_next_chain(dispenser50)
        dispenser50.set_next_chain(dispenser20)
        dispenser20.set_next_chain(dispenser10)  # Add to chain
        self.chain = dispenser100

Java

NewDenomination.java

class NoteDispenser10 extends NoteDispenser {
    public NoteDispenser10(int numNotes) {
        super(10, numNotes);
    }
}

// Update CashDispenser
class CashDispenser {
    public CashDispenser() {
        NoteDispenser100 dispenser100 = new NoteDispenser100(10);
        NoteDispenser50 dispenser50 = new NoteDispenser50(20);
        NoteDispenser20 dispenser20 = new NoteDispenser20(30);
        NoteDispenser10 dispenser10 = new NoteDispenser10(40);  // New!

        dispenser100.setNextChain(dispenser50);
        dispenser50.setNextChain(dispenser20);
        dispenser20.setNextChain(dispenser10);  // Add to chain
        this.chain = dispenser100;
    }
}

3. Add Transaction Classes (Strategy Pattern):

Python

transaction_strategy.py

class Transaction(ABC):
    """Base transaction class."""

    @abstractmethod
    def execute(self, atm: ATMSystem, card: Card, amount: int) -> bool:
        pass

class WithdrawalTransaction(Transaction):
    def execute(self, atm: ATMSystem, card: Card, amount: int) -> bool:
        if not atm.cash_dispenser.can_dispense_cash(amount):
            return False
        if atm.bank_service.withdraw_money(card, amount):
            atm.cash_dispenser.dispense_cash(amount)
            return True
        return False

class DepositTransaction(Transaction):
    def execute(self, atm: ATMSystem, card: Card, amount: int) -> bool:
        atm.bank_service.deposit_money(card, amount)
        return True

Java

TransactionStrategy.java

abstract class Transaction {
    abstract boolean execute(ATMSystem atm, Card card, int amount);
}

class WithdrawalTransaction extends Transaction {
    @Override
    public boolean execute(ATMSystem atm, Card card, int amount) {
        if (!atm.getCashDispenser().canDispenseCash(amount)) {
            return false;
        }
        if (atm.getBankService().withdrawMoney(card, amount)) {
            atm.getCashDispenser().dispenseCash(amount);
            return true;
        }
        return false;
    }
}

class DepositTransaction extends Transaction {
    @Override
    public boolean execute(ATMSystem atm, Card card, int amount) {
        atm.getBankService().depositMoney(card, amount);
        return true;
    }
}

Future Enhancements

1. PIN Attempt Limits:

• Track failed PIN attempts
• Lock card after 3 failed attempts
• Add CardBlockedState

2. Session Timeout:

• Auto-eject card after inactivity
• Add timeout mechanism

3. Transaction History:

• Store transaction log
• Add Transaction class with timestamps

4. Multi-Account Support:

• Link multiple accounts to one card
• Allow account selection

5. Different Currency Support:

• Handle multiple currencies
• Currency conversion

6. Biometric Authentication:

• Fingerprint/face recognition
• Add BiometricAuthState

7. Network Failure Handling:

• Queue transactions when bank is unreachable
• Retry mechanism

---

Summary

Key Takeaways

• Follow Systematic Approach - Don’t jump to code
• Identify Actors First - Who uses the system?
• Identify Entities - What are the core objects?
• Assign Responsibilities - Single Responsibility Principle
• Design Class Diagrams - Visualize structure and relationships
• Define Contracts - Clear interfaces and APIs
• Handle Edge Cases - Think about errors and concurrency
• Use Design Patterns - State Pattern, Chain of Responsibility, Singleton
• Make it Extensible - Easy to add new features

Design Patterns Used

1. State Pattern - ATM state management
2. Chain of Responsibility Pattern - Cash dispensing with multiple denominations
3. Singleton Pattern - Single ATM instance

Best Practices Demonstrated

• SOLID principles (SRP, OCP)
• Thread safety considerations
• Clear separation of concerns
• Extensible design
• Error handling
• Clean code structure

---

Next Steps

Now that you’ve mastered the ATM System:

Practice Similar Problems:

• Parking Lot System
• Elevator System
• Library Management System
• Restaurant Management System

Explore More Patterns:

• Strategy Pattern (for transaction processing)
• Observer Pattern (for notifications)
• Command Pattern (for operations)

Deepen Your Understanding:

• Read about concurrency patterns
• Study database design for persistence
• Learn about distributed systems
• Explore security best practices

---

Practice Makes Perfect

Try implementing this system yourself! Start with the basic version, then add:

• PIN attempt limits
• Session timeout
• Transaction history
• Multi-account support

The more you practice, the better you’ll become at LLD interviews! 🚀