ATM study case.

Class ATM

1. public class ATM
2. {
3.     private boolean userAuthenticated;
4.     private int currentAccountNumber;
5.     private Screen screen;
6.     private Keypad keypad;
7.     private CashDispenser cashDispenser;
8.     private DepositSlot depositSlot;
9.     private BankDatabase bankDatabase;
10.    
11.     private static final int BALANCE_INQUIRY = 1;
12.     private static final int WITHDRAWAL = 2;
13.     private static final int DEPOSIT = 3;
14.     private static final int EXIT = 4;
15.    
16.     public ATM()
17.     {
18.         userAuthenticated = false;
19.         currentAccountNumber = 0;
20.         screen = new Screen();
21.         keypad = new Keypad();
22.         cashDispenser = new CashDispenser();
23.         depositSlot = new DepositSlot();
24.         bankDatabase = new BankDatabase();
25.     }
26.    
27.     public void run()
28.     {
29.         while(true)
30.         {
31.             while(!userAuthenticated)
32.             {
33.                 screen.displayMessageLine("\nWelcome!");
34.                 authenticateUser();
35.             }
36.            
37.             performTransactions();
38.             userAuthenticated=false;
39.             currentAccountNumber=0;
40.             screen.displayMessageLine("\nThank you! Goodbye!");
41.         }
42.     }
43.    
44.     private void authenticateUser()
45.     {
46.         screen.displayMessage("\nPlease enter your account number : ");
47.         int accountNumber = keypad.getInput();
48.         screen.displayMessage("\nEnter your PIN: ");
49.         int pin = keypad.getInput();
50.        
51.         userAuthenticated =
52.             bankDatabase.authenticateUser(accountNumber, pin);
53.            
54.         if(userAuthenticated)
55.         {
56.             currentAccountNumber = accountNumber;
57.         }
58.         else
59.             screen.displayMessageLine(
60.                 "Invalid account number or PIN. Please try again");
61.     }
62.    
63.     private void performTransactions()
64.     {
65.         Transaction currentTransaction = null;
66.        
67.         boolean userExited = false;
68.        
69.         while (!userExited)
70.         {
71.             int mainMenuSelection = displayMainMenu();
72.            
73.             switch(mainMenuSelection)
74.             {
75.                 case BALANCE_INQUIRY:
76.                 case WITHDRAWAL:
77.                 case DEPOSIT:
78.                
79.                     currentTransaction =
80.                         createTransaction(mainMenuSelection);
81.                        
82.                     currentTransaction.execute();
83.                     break;
84.                 case EXIT:
85.                     screen.displayMessageLine("\nExiting the system...");
86.                     userExited = true;
87.                     break;
88.                 default:
89.                     screen.displayMessageLine(
90.                     "\nYou did not enter a valid selection. Try again");
91.                     break;
92.                 }
93.             }
94.         }
95.     private int displayMainMenu()
96.     {
97.         screen.displayMessageLine("\nMain menu:");
98.         screen.displayMessageLine("1 - View my balance");
99.         screen.displayMessageLine("2 - Withdraw cash");
100.         screen.displayMessageLine("3 - Deposit funds");
101.         screen.displayMessageLine("4 - Exit\n");
102.         screen.displayMessage("Enter a choice : ");
103.         return keypad.getInput();
104.     }
105.    
106.     private Transaction createTransaction(int type)
107.     {
108.         Transaction temp = null;
109.        
110.         switch(type)
111.         {
112.             case BALANCE_INQUIRY:
113.                 temp = new BalanceInquiry(
114.                     currentAccountNumber, screen, bankDatabase);
115.                     break;
116.             case WITHDRAWAL :
117.                 temp = new Withdrawal(currentAccountNumber, screen,
118.                     bankDatabase, keypad, cashDispenser);
119.                     break;
120.             case DEPOSIT:
121.                 temp = new Deposit (currentAccountNumber, screen,
122.                     bankDatabase, keypad, depositSlot);
123.                     break;
124.                 }
125.         return temp;
126.     }
127. }

Class screen

1. public class Screen
2. {
3.     public void displayMessage( String message)
4.     {
5.         System.out.print(message);
6.     }
7.     public void displayMessageLine(String message)
8.     {
9.         System.out.println(message);
10.     }
11.     public void displayDollarAmount(double amount)
12.     {
13.         System.out.printf("$%,.2f", amount);
14.     }
15. }

Class keypad

1. import java.util.Scanner;
2. public class Keypad
3. {
4.     private Scanner input;
5.    
6.     public Keypad()
7.     {
8.         input = new Scanner(System.in);
9.     }
10.    
11.     public int getInput()
12.     {
13.         return input.nextInt();
14.     }
15. }

Class cash dispenser

1. public class CashDispenser
2. {
3.     private final static int INITIAL_COUNT=500;
4.     private int count;
5.    
6.     public CashDispenser()
7.     {
8.         count = INITIAL_COUNT;
9.     }
10.    
11.     public void dispenseCash(int amount)
12.     {
13.         int billsRequired = amount / 20;
14.         count-=billsRequired;
15.     }
16.    
17.     public boolean isSufficientCashAvailable(int amount)
18.     {
19.         int billsRequired = amount / 20;
20.        
21.         if (count >= billsRequired)
22.             return true;
23.         else
24.             return false;
25.     }
26.    
27. }

Class deposit slot

1. public class DepositSlot
2. {
3.   public boolean isEnvelopeReceived()
4.   {
5.       return true;
6.    }
7. }

Class Account

1. public class Account
2. {
3.    private int accountNumber;
4.    private int pin;
5.    private double availableBalance;
6.    private double totalBalance;
7.    
8.    public Account (int theAccountNumber, int thePIN,
9.         double theAvailableBalance, double theTotalBalance)
10.    {
11.        accountNumber = theAccountNumber;
12.        pin = thePIN;
13.        availableBalance = theAvailableBalance;
14.        totalBalance = theTotalBalance;
15.     }
16.    
17.     public boolean validatePIN(int userPIN)
18.     {
19.         if(userPIN == pin)
20.             return true;
21.         else
22.             return false;
23.     }
24.    
25.     public double getAvailableBalance()
26.     {
27.         return availableBalance;
28.     }
29.    
30.     public double getTotalBalance()
31.     {
32.         return totalBalance;
33.     }
34.    
35.     public void credit(double amount)
36.     {
37.         totalBalance +=amount;
38.     }
39.    
40.     public void debit(double amount)
41.     {
42.         availableBalance -=amount;
43.         totalBalance -= amount;
44.     }
45.    
46.     public int getAccountNumber()
47.     {
48.         return accountNumber;
49.     }
50. }

Class Bank Database

1. public class BankDatabase
2. {
3.     private Account[] accounts;
4.    
5.     public BankDatabase()
6.     {
7.         accounts = new Account[2];
8.         accounts[0] = new Account(12345, 54321, 1000.0, 1200.0);
9.         accounts[1] = new Account(98765, 56789, 200.0, 200.0);
10.     }
11.    
12.     private Account getAccount(int accountNumber)
13.     {
14.         for(Account currentAccount : accounts)
15.         {
16.             if(currentAccount.getAccountNumber() == accountNumber)
17.                 return currentAccount;
18.         }
19.         return null;
20.     }
21.    
22.     public boolean authenticateUser(int userAccountNumber, int userPIN)
23.     {
24.         Account userAccount = getAccount(userAccountNumber);
25.        
26.         if(userAccount != null)
27.             return userAccount.validatePIN(userPIN);
28.         else
29.             return false;
30.     }
31.    
32.     public double getAvailableBalance(int userAccountNumber)
33.     {
34.         return getAccount(userAccountNumber).getAvailableBalance();
35.     }
36.    
37.     public double getTotalBalance(int userAccountNumber)
38.     {
39.         return getAccount(userAccountNumber).getTotalBalance();
40.     }
41.    
42.     public void credit(int userAccountNumber, double amount)
43.     {
44.         getAccount(userAccountNumber).credit(amount);
45.     }
46.    
47.     public void debit(int userAccountNumber, double amount)
48.     {
49.         getAccount(userAccountNumber).debit(amount);
50.     }
51. }

Class Transaction

1. public abstract class Transaction
2. {
3.     private int accountNumber;
4.     private Screen screen;
5.     private BankDatabase bankDatabase;
6.    
7.     public Transaction(int userAccountNumber, Screen atmScreen,
8.         BankDatabase atmBankDatabase)
9.     {
10.         accountNumber = userAccountNumber;
11.         screen = atmScreen;
12.         bankDatabase = atmBankDatabase;
13.     }
14.    
15.     public int getAccountNumber()
16.     {
17.         return accountNumber;
18.     }
19.    
20.     public Screen getScreen()
21.     {
22.         return screen;
23.     }
24.    
25.     public BankDatabase getBankDatabase()
26.     {
27.         return bankDatabase;
28.     }
29.    
30.     abstract public void execute();
31. }

Class balance Inquiry

1. public class BalanceInquiry extends Transaction
2. {
3.     public BalanceInquiry(int userAccountNumber, Screen atmScreen,
4.         BankDatabase atmBankDatabase)
5.     {
6.         super(userAccountNumber, atmScreen, atmBankDatabase);
7.     }
8.    
9.     @Override
10.     public void execute()
11.     {
12.         BankDatabase bankDatabase = getBankDatabase();
13.         Screen screen = getScreen();
14.        
15.         double availableBalance =
16.             bankDatabase.getAvailableBalance(getAccountNumber());
17.        
18.         double totalBalance =
19.             bankDatabase.getTotalBalance(getAccountNumber());
20.            
21.         screen.displayMessageLine("\nBalanceInformation:");
22.         screen.displayMessage(" - Available balance : ");
23.         screen.displayDollarAmount(availableBalance);
24.         screen.displayMessage("\n - Total balance :     ");
25.         screen.displayDollarAmount(totalBalance);
26.         screen.displayMessageLine( "" );
27.     }
28. }

Class Withdrawal

1. public class Withdrawal extends Transaction
2. {
3.     private int amount;
4.     private Keypad keypad;
5.     private CashDispenser cashDispenser;
6.    
7.     private final static int CANCELED = 6;
8.    
9.     public Withdrawal(int userAccountNumber, Screen atmScreen,
10.         BankDatabase atmBankDatabase, Keypad atmKeypad,
11.         CashDispenser atmCashDispenser)
12.     {
13.         super(userAccountNumber, atmScreen, atmBankDatabase);
14.        
15.         keypad = atmKeypad;
16.         cashDispenser = atmCashDispenser;
17.     }
18.    
19.     @Override
20.     public void execute()
21.     {
22.         boolean cashDispensed = false;
23.         double availableBalance;
24.        
25.         BankDatabase bankDatabase = getBankDatabase();
26.         Screen screen = getScreen();
27.        
28.         do
29.         {
30.             amount = displayMenuOfAmounts();
31.            
32.             if(amount!= CANCELED)
33.             {
34.                 availableBalance = bankDatabase.getAvailableBalance(getAccountNumber());
35.                
36.                 if(amount <= availableBalance)
37.                 {
38.                     if(cashDispenser.isSufficientCashAvailable(amount))
39.                     {
40.                         bankDatabase.debit(getAccountNumber(), amount);
41.                        
42.                         cashDispenser.dispenseCash(amount);
43.                         cashDispensed = true;
44.                        
45.                         screen.displayMessageLine("\nYour cash has been"
46.                         + " dispensed. Please take your cash now.");
47.                     }
48.                     else
49.                         screen.displayMessageLine(
50.                         "\nInsufficient cash available in the ATM." +
51.                         "\n\nPlease choose a smaller amount.");
52.                 }
53.                 else
54.                 {
55.                     screen.displayMessageLine(
56.                         "\nInsufficient funds in your account." +
57.                         "\n\nPlease choose a smaller amount.");
58.                 }
59.             }
60.             else
61.             {
62.                 screen.displayMessageLine("\nCanceling transaction...");
63.                 return;
64.             }  
65.         } while( !cashDispensed );
66.        
67.     }
68.        
69.     private int displayMenuOfAmounts()
70.     {
71.         int userChoice = 0;
72.        
73.         Screen screen = getScreen();
74.        
75.         int[] amounts = {0, 20, 40, 60, 100, 200};
76.        
77.         while(userChoice ==0)
78.         {
79.             screen.displayMessageLine("\nWithdrawal Menu:");
80.             screen.displayMessageLine("1 - $20");
81.             screen.displayMessageLine("2 - $40");
82.             screen.displayMessageLine("3 - $60");
83.             screen.displayMessageLine("4 - $100");
84.             screen.displayMessageLine("5 - $200");
85.             screen.displayMessageLine("6 - Cancel transaction");
86.             screen.displayMessage("\nChoose a withdrawal amount: ");
87.            
88.             int input = keypad.getInput();
89.            
90.             switch(input)
91.             {
92.                 case 1:
93.                 case 2:
94.                 case 3:
95.                 case 4:
96.                 case 5:
97.                     userChoice = amounts[input];
98.                     break;
99.                 case CANCELED:
100.                     userChoice = CANCELED;
101.                     break;
102.                 default:
103.                     screen.displayMessageLine(
104.                         "\nInvalid selection. Try again.");
105.             }
106.         }
107.         return userChoice;
108.     }
109.  
110. }

Class Deposit

1. public class Deposit extends Transaction
2. {
3.     private double amount;
4.     private Keypad keypad;
5.     private DepositSlot depositSlot;
6.     private final static int CANCELED = 0;
7.  
8.  
9.     public Deposit(int userAccountNumber, Screen atmScreen, BankDatabase atmBankDatabase, Keypad atmKeypad, DepositSlot atmDepositSlot){    
10.        
11.         super(userAccountNumber, atmScreen, atmBankDatabase);
12.  
13.         keypad = atmKeypad;
14.         depositSlot = atmDepositSlot;
15.     }
16.     @Override
17.     public void execute(){
18.         BankDatabase bankDatabase = getBankDatabase();
19.         Screen screen = getScreen();
20.        
21.         amount = promptForDepositAmount();
22.        
23.         if(amount != CANCELED){
24.  
25.             screen.displayMessage("\nPlease insert a deposit envelope containing ");
26.             screen.displayDollarAmount(amount);
27.             screen.displayMessage(".");
28.  
29.             boolean envelopeReceived = depositSlot.isEnvelopeReceived();
30.  
31.             if(envelopeReceived){
32.                 screen.displayMessageLine("\nYour envelope has been received.");
33.                 screen.displayMessage("NOTE: The money just deposited will not be available until we verify the amount");
34.                 screen.displayMessage("of any enclosed cash and your checks clear.");
35.  
36.                 bankDatabase.credit(getAccountNumber(), amount);
37.             }
38.             else{
39.  
40.                 screen.displayMessageLine("\nYou did not insert an envelope");
41.                 screen.displayMessageLine("So, the ATM has canceled your transaction.");
42.             }
43.         }
44.         else{
45.  
46.             screen.displayMessageLine("\nCanceling transaction...");
47.         }
48.     }
49.  
50.     private double promptForDepositAmount(){
51.         Screen screen = getScreen();
52.         screen.displayMessage("\nPlease enter a deposit amount in" + "CENTS (or 0 to cancel)");
53.         int input = keypad.getInput();
54.  
55.         if(input == CANCELED) return CANCELED;
56.         else{
57.             return (double) input;
58.         }  
59.     }
60. }

Class ATM case Study

1. public class ATMCaseStudy
2. {
3.     public static void main(String[] args)
4.     {
5.         ATM theATM = new ATM();
6.         theATM.run();
7.     }
8. }