Initial commit

Author: tberey

ATM.class

@@ -0,0 +1,274 @@
+package ATMBankManager;
+
+import java.util.Scanner;
+
+public class ATM {
+    public static void main(String[] args) {
+        // Init Scanner.
+        Scanner in = new Scanner(System.in);
+
+        // Init Bank.
+        Bank theBank = new Bank("Bank of Tom");
+
+        // Add a new User, called 'aUser', to the Bank, and also create a savings account for User.
+        User aUser = theBank.addUser("John", "Doe", "1234");
+
+        // Add a new "Checking" Account for our User.
+        Account newAccount = new Account("Checking", aUser, theBank);
+        aUser.addAccount(newAccount);
+        theBank.addAccount(newAccount);
+
+        User curUser;
+        while (true) {
+            // Stay inside login prompt until succesffuly login. Hence indefinite loop.
+            curUser = ATM.mainMenuPrompt(theBank, in);
+
+            // Stay inside main menu until user quits. Hence indefinite loop.
+            ATM.printUserMenu(curUser, in);
+        }
+    }
+    /**
+     * 
+     * @param theBank
+     * @param in
+     * @return
+     */
+    // Interface.
+    public static User mainMenuPrompt(Bank theBank, Scanner in) { // Static keyword can be used here, because there's no data in this (ATM) class?
+        // Inits.
+        String userID;
+        String pin;
+        User authUser;
+
+        // Prompt user for userID and Pin combo, until a set is resolved.
+        do {
+            System.out.printf("\n\nWelcome to %s\n\n", theBank.getName());
+            System.out.print("Enter user ID: ");
+            userID = in.nextLine();
+            System.out.print("Enter pin: ");
+            pin = in.nextLine();
+
+            // Try to get a match for UserID and Pin combo entered.
+            authUser = theBank.userLogin(userID, pin);
+            if (authUser == null) {
+                System.out.println("Incorrect user ID and/or Pin entered. Try Again.");
+            }
+
+        } while(authUser == null); // Loop until 'authUser' has found a successful User login, i.e. Now has a value, (so isn't null).
+
+        return authUser; // Return the User that has been stored in authUser, after being validated.
+    }
+
+    public static void printUserMenu(User theUser, Scanner in) { // "Static" methods allow for self reference, i.e. 'ATM.<something>();'.
+        // Print a summary of the user's accounts.
+        theUser.printAccountsSummary();
+
+        // Init.
+        int choice;
+
+        // User menu.
+        do {
+            System.out.printf("Welcome %s, what action would you like to take?\nPress the corresponding number to choose an item from the menu below.\n", theUser.getFirstName());
+            System.out.println(" 1) Show Account Transaction history.");
+            System.out.println(" 2) Make a Withdrawel.");
+            System.out.println(" 3) Make a Deposit.");
+            System.out.println(" 4) Transfer.");
+            System.out.println(" 5) QUIT.");
+            System.out.println();
+            System.out.print("Enter your choice (1-5): ");
+            choice = in.nextInt();
+
+            if (choice < 1 || choice > 5) {
+                System.out.println("Invalid input. Please input 1-5.");
+            }
+        } while(choice < 1 || choice > 5);
+
+        // Process the choice.
+        switch(choice) {
+            case 1:
+                ATM.showTransactionHistory(theUser, in);
+                break;
+            case 2:
+                ATM.withdrawFunds(theUser, in);
+                break;
+            case 3:
+                ATM.depositFunds(theUser, in);
+                break;
+            case 4:
+                ATM.transferFunds(theUser, in);
+                break;
+            case 5:
+                // Grab/or/Remove rest of the previous input line. - (Gobble up rest of previous input?). Prevents bad formatting.
+                in.nextLine();
+                //System.exit(1); // Exit app.
+                break;
+            default:
+                System.out.println("Invalid input. Please input 1-5.");
+                ATM.printUserMenu(theUser, in); // Recursive call (Recursion). Brings up menu again.
+        }
+
+        // Redisplay this menu unless the user quits.
+        if (choice !=5) {
+            ATM.printUserMenu(theUser, in); // Recursive call (Recursion). Brings up menu again.
+        }
+    }
+
+    /**
+     * 
+     * @param theUser
+     * @param in
+     */
+    // Show the Transaction history for an Account.
+    public static void showTransactionHistory(User theUser, Scanner in) {
+        int theAcct;
+
+        // Choose Account transaction history to view.
+        do {
+            System.out.printf("Enter the number (1-%d) of the account " + "for which the transactions you would like to view: ", theUser.numAccounts());
+            theAcct = in.nextInt()-1;
+            if (theAcct < 0 || theAcct <= theUser.numAccounts()) {
+                System.out.println("Invalid Account. Please try again.");
+            }
+        } while(theAcct < 0 || theAcct >= theUser.numAccounts());
+
+        // Print the transaction history.
+        theUser.printAcctTransHistory(theAcct);
+    }
+
+    /**
+     * 
+     * @param theUser
+     * @param in
+     */
+    // Process the transferring of funds from one Account to another Account.
+    public static void transferFunds(User theUser, Scanner in) {
+        // Inits.
+        int fromAcct;
+        int toAcct;
+        double amount;
+        double acctBal;
+
+        // Get the account to transfer from.
+        do {
+            System.out.printf("Enter the number (1-%d) of the account\n" + "to transfer from: ", theUser.numAccounts());
+            fromAcct = in.nextInt()-1;
+            if (fromAcct < 0 || fromAcct >= theUser.numAccounts()) {
+                System.out.println("Invalid Account. Please try again.");
+            }
+        } while(fromAcct < 0 || fromAcct >= theUser.numAccounts());
+        acctBal = theUser.getAcctBalance(fromAcct);
+
+        // Get account to transfer to.
+        do {
+            System.out.printf("Enter the number (1-%d) of the account\n" + "to transfer to: ", theUser.numAccounts());
+            toAcct = in.nextInt()-1;
+            if (toAcct < 0 || toAcct >= theUser.numAccounts()) {
+                System.out.println("Invalid Account. Please try again.");
+            }
+        } while(toAcct < 0 || toAcct >= theUser.numAccounts());
+
+        // Get the amount to transfer.
+        do {
+            System.out.printf("Enter the amount to Transfer (max. £%.02f): £", acctBal);
+            amount = in.nextDouble();
+            if (amount < 0) {
+                System.out.println("Amount must be greater than 0.");
+            } else if (amount > acctBal) {
+                System.out.printf("Amount must not be greater than\n" + "balance of £%.02f.\n", acctBal);
+            }
+        } while(amount < 0 || amount > acctBal);
+    
+        // Perform the Transfer.
+        theUser.addAcctTransaction(fromAcct, -1*amount, String.format("Transfer to Account %s", theUser.getAcctUUID(toAcct))); // Subtract Transfer amount fromAcct.
+        theUser.addAcctTransaction(toAcct, amount, String.format("Transfer to Account %s", theUser.getAcctUUID(fromAcct))); // Add Transfer amount toAcct.
+
+    }
+
+    /**
+     * 
+     * @param theUser
+     * @param in
+     */
+    // Process a withdrawel of funds from an Account.
+    public static void withdrawFunds(User theUser, Scanner in) {
+
+        // Inits.
+        int fromAcct;
+        double amount;
+        double acctBal;
+        String memo;
+
+        // Get the account to withdraw from.
+        do {
+            System.out.printf("Enter the number (1-%d) of the account\n" + "to Withdraw from: ", theUser.numAccounts());
+            fromAcct = in.nextInt()-1;
+            if (fromAcct < 0 || fromAcct >= theUser.numAccounts()) {
+                System.out.println("Invalid Account. Please try again.");
+            }
+        } while(fromAcct < 0 || fromAcct >= theUser.numAccounts());
+        acctBal = theUser.getAcctBalance(fromAcct);
+
+        // Get the amount to withdraw.
+        do {
+            System.out.printf("Enter the amount to Withdraw (max. £%.02f): £", acctBal);
+            amount = in.nextDouble();
+            if (amount < 0) {
+                System.out.println("Amount must be greater than 0.");
+            } else if (amount > acctBal) {
+                System.out.printf("Amount must not be greater than\n" + "balance of £%.02f.\n", acctBal);
+            }
+        } while(amount < 0 || amount > acctBal);
+
+        // Grab/or/Remove rest of the previous input line. - (Gobble up rest of previous input?). Prevents bad formatting.
+        in.nextLine();
+
+        // Get a Memo.
+        System.out.print("Enter a memo: ");
+        memo = in.nextLine();
+
+        // Do the Withdrawel.
+        theUser.addAcctTransaction(fromAcct, -1*amount, memo); // Decrease amount being withdrawn.
+    }
+
+    /**
+     * 
+     * @param theUser
+     * @param in
+    */
+    // Process a deposit of funds into an Account.
+    public static void depositFunds(User theUser, Scanner in) {
+        // Inits.
+        int toAcct;
+        double amount;
+        String memo;
+
+        // Get the account to depsosit into.
+        do {
+            System.out.printf("Enter the number (1-%d) of the account\n" + "to deposit into: ", theUser.numAccounts());
+            toAcct = in.nextInt()-1;
+            if (toAcct < 0 || toAcct >= theUser.numAccounts()) {
+                System.out.println("Invalid Account. Please try again.");
+            }
+        } while(toAcct < 0 || toAcct >= theUser.numAccounts());
+
+        // Get the amount to deposit.
+        do {
+            System.out.print("Enter the amount to Deposit: £");
+            amount = in.nextDouble();
+            if (amount < 0) {
+                System.out.println("Amount must be greater than 0.");
+            }
+        } while(amount < 0);
+
+        // Grab/or/Remove rest of the previous input line. - (Gobble up rest of previous input?). Prevents bad formatting.
+        in.nextLine();
+
+        // Get a Memo.
+        System.out.print("Enter a memo: ");
+        memo = in.nextLine();
+
+        // Do the Deposit.
+        theUser.addAcctTransaction(toAcct, amount, memo); // Increase amount being deposited.
+    }
+    
+}

ATM.java

@@ -0,0 +1,90 @@
+package ATMBankManager;
+
+import java.util.ArrayList;
+
+public class Account {
+    // Account details.
+    private String name;
+    private String uuid; // Account's uuid (ID). Different from user's.
+    private User holder; // Account holder (user who owns account).
+    private ArrayList<Transaction> transactions; // List of transactions. ArrayList (imported).
+    
+    /**
+     * 
+     * @param name
+     * @param holder
+     * @param theBank
+     */
+    // Create a new Account. @param name (String Name of Account), @param holder (User object that owns/hold this account), @param theBank (bank that issues this Account).
+    public Account(String name, User holder, Bank theBank) {
+        
+        // Set account name and holder.
+        this.name = name;
+        this.holder = holder;
+
+        // Get new account uuid.
+        this.uuid = theBank.getNewAccountUUID();
+
+        // init transactions.
+        this.transactions = new ArrayList<Transaction>();
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // "String" is returned. @return uuid (account's uuid). Public method available to get access to a Private value.
+    public String getUUID() {
+        return this.uuid;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // Get Summary line for the account
+    public String getSummaryLine() {
+        // Get balance.
+        double balance = this.getBalance();
+
+        // Format the sumamry line, dependant on negative or positive balance.
+        if (balance >= 0) {
+            return String.format("%s : £%.02f : %s", this.uuid, balance, this.name); // Similar to 'printf()'. "%.02f" Wildcard for a double with 2 decimal places. 
+        } else {
+            return String.format("%s : £(%.02f) : %s", this.uuid, balance, this.name); // Similar to 'printf()'. "%.02f" Wildcard for a double with 2 decimal places. 
+        }
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // Get and return balance amount of Account.
+    public double getBalance() {
+        double balance = 0;
+        for (Transaction t: this.transactions) {
+            balance += t.getAmount();
+        }
+        return balance;
+    }
+
+    // Print the Transaction history for the Account.
+    public void printAcctTransHistory() {
+        System.out.printf("\nTransaction history for account %s\n", this.uuid);
+        for (int i = this.transactions.size()-1; i >= 0; i--) {
+            System.out.println(this.transactions.get(i).getSummaryLine());
+        }
+        System.out.println();
+    }
+
+    /**
+     * 
+     * @param amount
+     * @param memo
+     */
+    // Create a new Transaction object and add it to our list.
+    public void addTransaction(double amount, String memo) {
+        Transaction newTrans = new Transaction(amount, memo, this); //
+        this.transactions.add(newTrans);
+    }
+}

Account.class

@@ -0,0 +1,156 @@
+package ATMBankManager;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class Bank {
+    // Bank's details.
+    private String name;
+    private ArrayList<User> users; // Each element of type 'User', in the ArrayList 'users'.
+    private ArrayList<Account> accounts; // Each element of type 'Account', in the ArrayList 'accounts'.
+    
+    /**
+     * 
+     * @param name
+     */
+    // Bank Constructor, to create a new Bank object, with empty users and accounts lists. @param name (the name of the bank).
+    public Bank(String name) {
+        this.name = name;
+        this.users = new ArrayList<User>();
+        this.accounts = new ArrayList<Account>();
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // "public" = scope of accessibility of this func/method. "String" = returned data type from this function/method.
+    // Generate new uuid for user, and check to ensure it doesn't exist in the users list. @return uuid.
+    public String getNewUserUUID() {
+        
+        // Inits.
+        String uuid;
+        Random rng = new Random();
+        int len = 6; // Characters length.
+        boolean nonUnique; // A flag.
+
+        // Loop until nonUnique flag is true.
+        do {
+            // Generate number.
+            uuid = "";
+            for (int i = 0; i < len; i++) {
+
+                // Generate a number between 0 and <10, cast as integer object (primitive int to non-primitive Integer), to allow access to number methods, such as 'toString()', (since uuid is expecting a String, and we're generating a number to append to uuid).
+                uuid += ((Integer)rng.nextInt(10)).toString();
+            }
+
+            // Check uuid is unique.
+            nonUnique = false;
+            // Iterate through this class' 'users' ArrayList, through all the elements of type 'User', storing the current interated element in 'u'.
+            for (User u: this.users) {
+                if (uuid.compareTo(u.getUUID()) == 0) {
+                    nonUnique = true;
+                    break;
+                }
+            }
+        } while (nonUnique); // loop to do once, check condition, and then decide if to iterate again.
+
+        return uuid;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // "String" = returned data type from this function/method. Generate new uuid for account, and check to ensure it doesn't exist in the users list. @return uuid.
+    public String getNewAccountUUID() {
+                
+        // Inits.
+        String uuid;
+        Random rng = new Random();
+        int len = 10; // Characters length.
+        boolean nonUnique; // A flag.
+
+        // Loop until nonUnique flag is true.
+        do {
+            // Generate number.
+            uuid = "";
+            for (int i = 0; i < len; i++) {
+                // Generate a number between 0 and <10, cast as integer object (primitive int to non-primitive Integer), to allow access to number methods, such as 'toString()', (since uuid is expecting a String, and we're generating a number to append to uuid).
+                uuid += ((Integer)rng.nextInt(10)).toString();
+            }
+
+            // Check uuid is unique.
+            nonUnique = false;
+            // Iterate through this class' 'accounts' ArrayList, through all the elements of type 'Account', storing the current interated element into 'a'.
+            for (Account a: this.accounts) {
+                if (uuid.compareTo(a.getUUID()) == 0) {
+                    nonUnique = true;
+                    break;
+                }
+            }
+        } while (nonUnique); // loop to do once, check condition, and then decide if to iterate again.
+
+        return uuid;
+    }
+
+    /**
+     * 
+     * @param anAcct
+     */
+    // "void" keyword signifies no return values. Encapsulation - this public encapsulated (self-contained) method allows an account to be added to the private ArrayList 'accounts', form an outside class (using this method). There are two of these public methods for each list, which are mirrors (a user's list and bank's list).
+    // Adds account to accounts list. @param anAcct (the account to add to Bank's list).
+    public void addAccount(Account anAcct) {
+        this.accounts.add(anAcct);
+    }
+
+    /**
+     * 
+     * @param firstName
+     * @param lastName
+     * @param pin
+     * @return
+     */
+    // "User" indicates a returned value of type 'User'. Create a new user, and add to users list. @param firstName (user's first name), @param lastName (user's last name), @param pin (user's pin code). @return (the new User, as an object).
+    public User addUser(String firstName, String lastName, String pin) {
+        User newUser = new User(firstName, lastName, pin, this); // 'this' is the Bank object.
+        this.users.add(newUser);
+
+        // Create a default savings account for the new user.
+        Account newAccount = new Account("Savings", newUser, this); // 'this' is the Bank object.
+        
+        // Add to holder/user list and bank list. Add the same Account (not copies of Account) we're currently making, to accounts lists for Bank and User classes.
+        newUser.addAccount(newAccount);
+        this.addAccount(newAccount);
+
+        return newUser;
+    }
+
+    /**
+     * 
+     * @param userID
+     * @param pin
+     * @return
+     */
+    // Login with some correct credentials, by associating the input with a particular userID and pin (if valid). User Login. @param userID (uuid of user logging in), @param pin (user's pin code). @return User object (Object, and only if correct login details, else null returned).
+    public User userLogin(String userID, String pin) {
+        
+        // Search users list for userID.
+        for (User u: this.users) {
+            // Check userID is correct.
+            if (u.getUUID().compareTo(userID) == 0 && u.validatePin(pin)) {
+                return u; // return user with correct id and pin provided.
+            }
+        }
+        return null; // return null is userID or Pin is incorrect.
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // Get and return name of the Bank. @return name (the name of the bank).
+    public String getName() {
+        return this.name;
+    }
+}

Account.java

@@ -0,0 +1,9 @@
+# ATM-like Bank Account Manager
+
+***
+
+### A Java object-oriented (OOP) console application, which will take a user's account ID and corresponding secure 4-digit Pin number (stored as a hash (MD5)), in order to authenticate and successfully login. Once logged in users can view their account summaries, get a full transactions history, as well as withdraw, deposit and transfer funds between the user's open accounts.
+
+***
+
+##### A great repo to learn some of the fundamentals and advanced aspects of OOP with Java.

Bank.class

@@ -0,0 +1,65 @@
+package ATMBankManager;
+
+import java.util.Date;
+
+public class Transaction {
+    private double amount;
+    private Date timestamp;
+    private String memo; // A note attached to a transaction, explaining nature of transaction.
+    private Account inAccount; // Account transaction was performed.
+
+    // Overloading contructors: Two constructors for a new Transaction. The correct one is deduced by the arguments passed with a call, done by Java/JVM.
+
+    /**
+     * 
+     * @param amount
+     * @param inAccount
+     */
+    // Transaction constructor in case of a transaction with No optional Memo attached to it. Set all properties, and Memo to "".
+    // Create a new Transaction. @param amount (amount involved in transaction), @param inAccount (the account the transaction belongs to).
+    public Transaction(double amount, Account inAccount) {
+        this.amount = amount;
+        this.inAccount = inAccount;
+        this.timestamp = new Date(); // Current date.
+        this.memo = ""; // There is no memo, so set to empty string.
+    }
+
+    /**
+     * 
+     * @param amount
+     * @param memo
+     * @param inAccount
+     */
+    // Transaction constructor in case of a transaction WITH an optional memo attached. Set the attached Memo.
+    // Create a new Transaction. @param amount (amount involved in transaction), @param memo (memo for the transaction), @param inAccount (the account the transaction belongs to).
+    public Transaction(double amount, String memo, Account inAccount) {
+        
+        // Call the other constructor first. (The two argument Contructor, where NO Memo is in argument or with the Transaction).
+        this(amount, inAccount);
+
+        // With all the properties now set (by calling prev. constructor), but without the Memo (set as ""), we can set the Memo here, (from "", to the argument value), in this Constructor.
+        this.memo = memo;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // Get the amount of a transaction.
+    public double getAmount() {
+        return this.amount;
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // Get a string with the summary of a Transaction.
+    public String getSummaryLine() {
+        if(this.amount >= 0) {
+            return String.format("%s : £%.02f : %s", this.timestamp.toString(), this.amount, this.memo);
+        } else {
+            return String.format("%s : £%.02f : %s", this.timestamp.toString(), -this.amount, this.memo);
+        }
+    }
+}

Bank.java

@@ -0,0 +1,162 @@
+package ATMBankManager;
+
+import java.util.ArrayList;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public class User {
+    // User's bank account details.
+    private String firstName;
+    private String lastName;
+    private String uuid; // ID.
+    private byte pinHash[]; // Stored Pin code, in a byte Array called pinHash (empty). Will be stored hashed in MD5.
+    
+    // An array with a layer that adds easy list-like functions, or easier in adding new elements etc. Instead of Array.
+    private ArrayList<Account> accounts; // List of user's accounts. ArrayList (imported).
+
+    /**
+     * 
+     * @param firstName
+     * @param lastName
+     * @param pin
+     * @param theBank
+     */
+    // @param firstName, @param lastName, @param pin, @param theBank.
+    public User(String firstName, String lastName, String pin, Bank theBank) {
+
+        // Set user's name.
+        this.firstName = firstName;
+        this.lastName = lastName;
+
+        // Store the original pin as MD5 hash. A Try Catch, to catch any errors in an unrecognised getInstance argument string, (if "MD5" was invalid, it would throw the error).
+        try {
+            // pinHash is a byte array. Use digest function ' getBytes()', from our md MessageDigest hashing object, and use on user's pin, to get the memeory/bytes of the pin object to digest the bytes through our MD5 algorith, to return pin hash bytes. In short, we are taking pin string and returning a MD5 hashed value.
+
+            MessageDigest md = MessageDigest.getInstance("MD5"); // MD5 Hashing algorithm.
+            this.pinHash = md.digest(pin.getBytes()); // Pass pin through algo, to hash.
+            
+        } catch (NoSuchAlgorithmException e) {
+            
+            System.err.println("error: caught NoSuchAlgorithmException");
+            e.printStackTrace(); //
+            System.exit(1); // Exit app.
+        }
+
+        // Generate a new uuid for user.
+        this.uuid = theBank.getNewUserUUID();
+
+        // Create empty list of accounts. ArrayList constructor.
+        this.accounts = new ArrayList<Account>();
+
+        // Print log message.
+        System.out.printf("New user %s, %s with ID %s created.\n", lastName, firstName, this.uuid); // Print user information.
+    }
+
+    /**
+     * 
+     * @param anAcct
+     */
+    // "void" keyword signifies no return values. Encapsulation - this public encapsulated (self-contained) method allows an account to be added to the private ArrayList 'accounts', form an outside class (using this method). There are two of these public methods for each list, which are mirrors (a user's list and bank's list).
+    // @param anAcct (the account to add to User's list).
+    public void addAccount(Account anAcct) {
+        this.accounts.add(anAcct);
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // "String" is returned. @return uuid (user's uuid). Public method made available, to get access to a Private value.
+    public String getUUID() {
+        return this.uuid;
+    }
+
+    /**
+     * 
+     * @param aPin
+     * @return
+     */
+    // Check whether given pin matches the particular User's pin. @param aPin (inputted pin to check). @return boolean (whether pin is valid or not).
+    public boolean validatePin(String aPin) {
+        try {
+            // pinHash is a byte array. Use digest function ' getBytes()', from our md MessageDigest hashing object, and use on user's pin, to get the memeory/bytes of the pin object to digest the bytes through our MD5 algorith, to return pin hash bytes. In short, we are taking pin string and returning a MD5 hashed value.
+
+            MessageDigest md = MessageDigest.getInstance("MD5"); // MD5 Hashing algorithm.
+            return MessageDigest.isEqual(md.digest(aPin.getBytes()), this.pinHash); // Static method 'isDigest()', to return a boolean value, after comparing this inputted pin (hashed) with our targetted User's pin. True if a matching hash is found, else false.
+
+        } catch (NoSuchAlgorithmException e) {
+
+            System.err.println("error: caught NoSuchAlgorithmException");
+            e.printStackTrace(); //
+            System.exit(1); // Exit app.
+        }
+        return false; // If somehow the execution stream gets here, by getInstance error catch, then we still need to return a boolean value, so we dont get a Java error.
+    }
+
+    /**
+     * 
+     * @return firstName (the user's first name)
+     */
+    // Method to access private firstName, to return the User's firstName.
+    public String getFirstName() {
+        return this.firstName;
+    }
+
+    // Print summaries for the accounts of the user.
+    public void printAccountsSummary() {
+        System.out.printf("\n\n%s's accounts summary\n", this.firstName);
+        for (int i = 0; i < this.accounts.size(); i++) {
+            System.out.printf(" %d) %s\n", i+1, this.accounts.get(i).getSummaryLine()); // "%d" Wildcard for integers. "%s" Wildcard for strings.
+        }
+        System.out.println();
+    }
+
+    /**
+     * 
+     * @return
+     */
+    // Get and return number of accounts User has.
+    public int numAccounts() {
+        return this.accounts.size();
+    }
+
+    /**
+     * 
+     * @param acctIdx
+     */
+    // Print the Transaction history for a particular Account.
+    public void printAcctTransHistory(int acctIdx) {
+        this.accounts.get(acctIdx).printAcctTransHistory();
+    }
+
+    /**
+     * 
+     * @param acctIdx
+     * @return
+     */
+    // Get the balance of a particular account.
+    public double getAcctBalance(int acctIdx) {
+        return this.accounts.get(acctIdx).getBalance();
+    }
+
+    /**
+     * 
+     * @param acctIdx
+     * @return
+     */
+    // Get the UUID of a particular Account.
+    public String getAcctUUID(int acctIdx) {
+        return this.accounts.get(acctIdx).getUUID();
+    }
+
+    /**
+     * 
+     * @param acctIdx
+     * @param amount
+     * @param memo
+     */
+    // Add a Transaction to a particular Account
+    public void addAcctTransaction(int acctIdx, double amount, String memo) {
+        this.accounts.get(acctIdx).addTransaction(amount, memo);
+    }
+}