ATM Class

[Kristina Hawkins]

Hello everybody,

I'm writing a simple code for ATM, but as I have never worked with a user's input, I'm not sure where to start.
I have written 3 classes

public class BankCustomer {
	
	private String firstName;
	private String lastName;
	private String accountNumber;
	private String password;
	private double balance;
	
	/**
	 * Default constructor for the BankCustomer class
	 */
	public BankCustomer ()
	{
		
	}
	
	/**
	 * Constructor to initialize
	 * @param firstName the firstName
	 * @param lastName the lastName
	 * @param accountNumber the accountNumber
	 * @param password the password
	 */
	public BankCustomer (String firstName, String lastName, String accountNumber, String password)
	{
		setFirstName(firstName);
		setLastName(lastName);
		setAccountNumber(accountNumber);
		setPassword(password);
	}

	/**
	 * 
	 * @return the firstName as a String
	 */
	public String getFirstName()
	{
		return firstName;
	}
	
	/**
	 * 
	 * @param firstName the firstName to set
	 */
	public void setFirstName(String firstName)
	{
		if (firstName != null)
		{
			this.firstName = firstName;
		}
	}
	
	/**
	 * 
	 * @return the LastName as a String
	 */
	public String getLastName ()
	{
		return lastName;
	}
	
	/**
	 * 
	 * @param lastName the lastName to set
	 */
	public void setLastName (String lastName)
	{
		if (lastName != null)
		{
			this.lastName = lastName;
		}
	}
	
	/**
	 * 
	 * @return the accountNumber as a String
	 */
	public  String getAccountNumber ()
	{
		return accountNumber;
	}
	
	/**
	 * 
	 * @param accountNumber the accountNumber to set
	 */
	public void setAccountNumber (String accountNumber)
	{
		if (accountNumber != null)
		{
			this.accountNumber = accountNumber;
		}
	}
	
	/**
	 * 
	 * @return the password as a String
	 */
	public String getPassword()
	{
		return password;
	}
	
	/**
	 * 
	 * @param password the password to set
	 */
	public void setPassword (String password)
	{
		if (password != null)
		{
			this.password = password;
		}
	}
	
	/**
	 * return the balance as a double
	 */
	public double getBalance()
	{
		return balance;
	}
	
	/**
	 * 
	 * @param balance the balance to set
	 */
	public void setBalance (double balance)
	{
		if (balance >= 0)
		{
			this.balance = balance;
		}
	}
	
	/**
	 * 
	 * @param amount to add to the balance
	 */
	public void addToBalance(double amount)
	{
		if (amount > 0)	
		{
			balance += amount;
		}
	}
	
	/**
	 * 
	 * @param amount to subtract from the balance
	 */
	public void subtractFromBalance (double amount)
	{
		if (amount > 0)
		{
			balance -= amount;
		}
	}
}

public class Bank {
	
	private HashMap <String, BankCustomer > theBank;
	
	/**
	 * Default construction for the Bank class
	 */
	public Bank()
	{
		theBank = new HashMap <String, BankCustomer> ();
	}
	
	/**
	 * 
	 * @param newCustomer is added to the collection
	 */
	public void createAccount (BankCustomer newCustomer)
	{
		if (newCustomer != null)
		{
			String accountNumber = newCustomer.getAccountNumber();
			theBank.put(accountNumber, newCustomer);
		}
	}
	
	/**
	 * 
	 * @param accountName is removed from the collection
	 */ 
	public void closeAccount (String accountName)
	{
		if (accountName != null)
		{
			theBank.remove(accountName);
		}
	}
	
	/**
	 * 
	 * @param accountName
	 * @param amount
	 */
	public void deposit (String accountName, double amount)
	{
		if (accountName != null)
		{
			theBank.get(accountName).addToBalance(amount);
		}
	}
	
	/**
	 * 
	 * @param accountName
	 * @param amount
	 */
	public void withdraw (String accountName, double amount)
	{
		if (accountName != null)
		{
			theBank.get(accountName).subtractFromBalance(amount);
		}
	}
	
	/**
	 * 
	 * @param customer
	 */
	public static void displayCustomerInformation (BankCustomer customer)
	{
		if (customer != null)
		{
			System.out.println(customer.toString());
		}
		
	}
}

public class InputReader {
	private Scanner scanner;

	/**
	 * Default constructor for InputReader class
	 * Create a new InputReader to read user input.
	 */
	public InputReader() {
		scanner = new Scanner(System.in);
	}

	/**
	 * Retrieves a user's int input
	 * @return the user's input as an int
	 */
	public int getIntInput() {
		try {
			return scanner.nextInt();
		} catch (java.util.InputMismatchException e) {
			System.out.println("Not a number - treating as zero");
			scanner.nextLine(); // clear the buffer
			return 0;
		}
	}

	
	/**
	 * Retrieves a user's double input
	 * @return the user's input as an double
	 */
	public double getDoubleInput() {
		try {
			return scanner.nextDouble();
		} catch (java.util.InputMismatchException e) {
			System.out.println("Not a number - treating as zero");
			scanner.nextLine(); // clear the buffer
			return 0.0;
		}
	}
}
	

Now I have to write a call where everything runs:


displayAccountInformation()
Displays a BankCustomer's account information if the customer has been previously verified.
void
initialize()
Adds Customer references to the Back HashMap as seed data for testing.
static void
main(java.lang.String[] args)
Main method calls the class default constructor.
void
run()
The primary application processor.
void
transactDeposit()
Performs a deposit into a BankCustomer's account.
void
transactWithdraw()
Performs a withdrawal from a BankCustomer's account.
void
verifyCustomer()
To confirm a BankCustomer's account number and passcode


and these are all methods that I have to use.

Thank you!

[Junilu Lacar]

Fantastic job with the formatting of your code! The classes appear to be well thought out and organized, too. Now as for how you'd tie everything together you might want to create another class, say an ATM class, to represent a bank customer's access point to the services of the bank that will be provided in some way by the classes you have defined. Don't take some of those instructions literally though because some of those method names mentioned in the instructions are not the same exact names you've used in your code; go by the intent because it's pretty easy to tell which one you really want to call. Go get user input, well, you already have written a class to handle that so all you have to do is call an appropriate method of that class.

[Kristina Hawkins]

import java.util.Scanner;
public class ATM {
	
	private Scanner s;
	
	
	public static void main(String[] args) {

	ATM newATM = new ATM();
	newATM.verifyCustomer();
	newATM.menu();
	
	
	}
	
	public ATM()
	{
		s = new Scanner(System.in);
	}
	
	public void menu()
	{
		System.out.println("Welcome to the bank");
		System.out.println("Choose one of the following options: ");
		System.out.println("1 - Sign In");
		System.out.println("2 - Deposit");
		System.out.println("3 - Withdraw");
		System.out.println("4 - Display Account Info");
		System.out.println("5 - Exit");
	}
	
	public void verifyCustomer()
	{
		BankCustomer customer1 = new BankCustomer("K", "H", "KBH", "2121");
		Bank theBank = new Bank();
		theBank.createAccount(customer1);
		
		System.out.println("Enter Account Number: ");
		String accountNumber;
		accountNumber = s.nextLine();
		System.out.println("Enter passcode");
		String passcode;
		passcode = s.nextLine();
		
		if (accountNumber.equals(customer1.getAccountNumber()) && passcode.equals(customer1.getPassword()))
		{
				menu();
				run();
			
			
		}
		else
		{
			System.out.println("ERROR: Either account number or passcode is not correct.");
		
		}
		
	}
	
	public void transactDeposit()
	{
		BankCustomer customer1 = new BankCustomer("K", "H", "KBH", "2121");
		Bank theBank = new Bank();
		theBank.createAccount(customer1);
		System.out.println("Enter the amount to deposit: ");
       double amount;
       amount = s.nextDouble();
		
		theBank.deposit(customer1.getAccountNumber(), amount);
		
	}
	
	public void transactWithdraw()
	{
		BankCustomer customer1 = new BankCustomer("K", "H", "KBH", "2121");
		Bank theBank = new Bank();
		theBank.createAccount(customer1);
		System.out.println("Enter the amount to withdraw: ");
       double amountW;
       amountW = s.nextDouble();
		
		theBank.withdraw(customer1.getAccountNumber(), amountW);
	}
	
	public void displayAccountInformation()
	{

		BankCustomer customer1 = new BankCustomer("K", "H", "KBH", "2121");
		Bank theBank = new Bank();
		theBank.createAccount(customer1);
		theBank.displayCustomerInformation(customer1);
	}
	
	public void run()
	{
		int choice;
		choice = s.nextInt();
		
		switch(choice)
		{
		case 1:
			verifyCustomer();
			break;
		case 2:
			transactDeposit();
			break;
		case 3:
			transactWithdraw();
			break;
		case 4:
			displayAccountInformation();
			break;
		}
	}
	

	
}

[Kristina Hawkins]

Thank you! This is what I have do far on my ATM class:)

[Kristina Hawkins]

I also have to use initialize () method to add customers to HashMap, not sure what to do here:(

and seems that my withdraw/deposit methods don't work properly too.

Any help or tips would be greatly appreciated!!!

[Swastik Dey]

Looks great.  But why are you doing this  
       

BankCustomer customer1 = new BankCustomer("K", "H", "KBH", "2121");
        Bank theBank = new Bank();

multiple times?  Will it not be better if you create multiple BankCustomer objects and maintain a map where account number is the key and the object is the value, and ideally your verify or other helper methods should also change.  You should first check whether the account number exists or not in the map, if exists the proceed with further operations.

[Kristina Hawkins]

That's where I'm stuck. I don't know how to do it

[Campbell Ritchie]

I haven't read your code well enough to be sure the Map is the best way to implement things, but Maps have all sorts of methods to find the sort of numbers you want. Start with the Java™ Tutorials.
By the way: Is “theBank” the best name for a Map?

[Junilu Lacar]

Kristina, you have to look past the technical/mechanical aspects of the instructions and understand the intent.  This will give you the context; that's what you're missing and that's why you're confused.  It's like somebody is telling you to "Jump three feet to your left! Right now!" and you're standing there looking confused.  If they had yelled out instead, "You're about to get hit by a bus!" then you'd have the proper context to do what you needed to do.

The instruction to "use initialize() method to add customers to HashMap" is like just telling you to jump three feet to your left. The intent is for you to create a Bank and set it up with a few BankCustomers so that the ATM can behave like a real ATM that can service multiple customers.

So, your ATM should be associated with a Bank which keeps information about which BankCustomers it has who keep their money at the Bank.

Now, think back to your own experience with ATMs.  You walk up, put your bank card in, enter your PIN, and then do things like withdraw, deposit, check balance, etc.  When you're done, your ATM session ends and the next person in line can come up and take his/her turn doing things at the ATM, except whatever that person does will pertain to their bank account, not yours.

Does this give you a better idea of what the ATM is supposed to do with its associated Bank object and that Bank object's associated BankCustomer objects?

Try to implement just one ATM function first, like logging in. So when there's no active BankCustomer using the ATM, it should just display something like: "Please enter your Account # to start:", then when the user enters that, they'd be prompted to "Please enter your PIN:" ...

I'll leave it to you to think through how the rest of that interaction would go.

[Junilu Lacar]

A few more things to clarify the intent of that initialize() method.  The reason for this method is to keep things simple. A real ATM doesn't get initialized with a Bank object and a few BankCustomers. A real ATM would be connected remotely to an application that's running in the bank's data center where all the information about bank customers are kept in huge databases that can hand thousands of simultaneous requests from multiple ATM machines.  Your program is only a small simulation that isn't actually connected to anything else. So, you have to somehow simulate the ATM reaching across a network and doing a bunch of complicated things to request information and submit transaction requests on behalf of the customer.

The initialize() method that you're supposed to write sets up that little simulated environment where you have a Bank that an ATM can go to and ask about customer account information or tell the Bank that the customer who's using the ATM just made a withdrawal or deposit or what not.

Does that make sense?

[Swastik Dey]

You may have a look on the following code.  It's the same what you have with few minor changes.

// *** Solution code DELETED by moderator ***

[Moderator edit: Please give OP a chance to do her own homework and come up with her own solution first. Thanks.]