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. }










Komentar

Posting Komentar

Postingan populer dari blog ini

UTS ,RK Covid-19

1.       1 Stake Holder : berperan sangat penting dalam tahapan pengembangan,sehingga stake holder  dalam aplikasi harus di definisikan.Karena itu Stake holder akan apklikasi ini adalah Stake Holder Subyek Keterangan Owner Project Pemerintah Provinsi jawa timur Penyandang dana Perwakilan Pemerintah Mengetahui alur aplikasi dan pengawasan Aplikasi Pengguna Pengelola Pegawai Dinias Petugas Umum User yang akan memakai aplikasi yang akan dibuat Pembuat Manajer Proyek Analyst Programmer Desainer Tester Impementasi Tim yang membuat program info covid19 2.       2. Tujuan dan Manfaat Infocovid19 ini bertujuan sebagai sumber informasi tentang kasus Covid-19(corona Virus) dan informasi penjelasan Covid-19.Informasi ini bertujuan untuk pencegahan penyebaran Cov...
Baca selengkapnya

FP PBO :Calendar viewer

Gambar
Berikut Ini adalah source codenya //Import packages import javax.swing.*; import javax.swing.event.*; import javax.swing.table.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class ViewCalendar {      JLabel lblMonth, lblYear;      JButton btnPrev, btnNext;      JTable tblCalendar;      JComboBox cmbYear;      JFrame frmMain;      Container pane;      DefaultTableModel mtblCalendar; //Table model      JScrollPane stblCalendar; //The scrollpane      JPanel pnlCalendar;      int realYear, realMonth, realDay, currentYear, currentMonth;     public void viewCalendar() {         System.out.println("*Calendar open*");         //Look and feel         try {             UIManager.setLookAnd...
Baca selengkapnya