Question

1. Checking and Savings accounts may not be the only types of accounts. Moreover, different account types may have different rules for withdrawal, interest calculation, etc. To support this, do the following:

   1. Create an abstraction (i.e., an interface or abstract class with no concrete implementation) to represent a generic bank account.

      1. All bank accounts have an account number, account holder(s) and a current balance. The abstraction must have functions to retrieve all these pieces of information.

      2. The abstraction must contain a function to add a new account holder.

      3. The abstraction must contain functions to support deposit and withdraw actions. The withdraw function must be capable of throwing an exception if there is insufficient account balance.

      4. The abstraction must contain a function to calculate interest using the current account balance and an interest rate and add that interest to the existing account balance. [Note: you can assume that some other entity is responsible for calling this function at the desired frequency, e.g., daily, monthly, etc.]

   2. Create a class with a function that automatically generates a unique bank account number. [Hint: the simplest approach is to use a static or class level attribute and corresponding function].

   3. Create a concrete implementation of the abstraction created in Step a to represent a Checking account. Assume these rules:

      1. It must be possible to create a Checking account with or without an initial deposit. The account number must be automatically generated using the generator from Step b.

      2. Any withdrawal that does not reduce the account balance to less than 0 is considered valid. If an invalid withdrawal occurs, an exception must be thrown indicating that the balance is insufficient to perform the withdrawal.

      3. A Checking account has a flat interest rate of 0.01%.

   4. Create a concrete implementation of the abstraction created in Step a to represent a Savings account. Assume the following rules:

      1. A Savings account requires a minimum initial deposit of $100. The account number must be automatically generated using the generator from Step b.

      2. A Savings account must maintain a minimum balance of $100 at all times. Any withdrawal that would make the balance go below this minimum amount is considered invalid. If an invalid withdrawal occurs, an exception must be thrown indicating that the balance is insufficient to perform the withdrawal.

      3. A Savings account has the following interest rates:

         1. < $2,000 balance: 0.01%

         2. >= $2,000 & < $12,000 balance: 0.05%

         3. >= $12,000 balance: 0.1%

   5. Create a bank account demo class. In this class, write a driver/main function to demonstrate your implementation. In this main function, do the following:

      1. Create a Checking account for Julio Perez with no initial deposit. Once the account is created, display the (generated) account number for the user’s benefit.

      2. Perform the following operations on Julio’s Checking account - after each operation below, display the current balance in the account:

         1. Deposit $1500 into the account.

         2. Withdraw $150 from the account.

         3. Perform interest accumulation (i.e., call the function that calculates and adds interest).

         4. Withdraw $750 from the account.

         5. Perform interest accumulation.

      3. Create a Savings account for Sasha Ivanov with an initial deposit of $600. Once the account is created, display the (generated) account number for the user’s benefit.

      4. Perform the following operations on Sasha’s Savings account - after each operation below, display the current balance in the account:

         1. Perform interest accumulation.

         2. Deposit $150 into the account.

         3. Perform interest accumulation.

         4. Withdraw $600 from the account.

Answer 1

The following bold text contains all the code and the description of code is given as comments:

CODE:

AbstractAccount.java

import java.util.ArrayList;

//This is the abstract class to represent a generic bank account.
public abstract class AbstractAccount {
    protected final int accountNo;
    protected ArrayList<String> holderNames;
    protected double balance;

    //This is the parameterized constructor
    public AbstractAccount(String holderNames, double balance) {
        this.accountNo = new AccountNumber().getNewAccountNo();
        this.holderNames = new ArrayList<>();
        this.holderNames.add(holderNames);
        this.balance = balance;
    }

    //the following are the abstract functions that are needed to be implemented concretely in the savings and the checking account class as mentioned in the problem statement.
    protected abstract int getAccountNo();

    protected abstract ArrayList<String> getHolderNames();

    protected abstract double getBalance();

    protected abstract void addNewAccountHolder(String holderName);

    public abstract void deposit(double depAmount);

    public abstract void withdraw(double amount) ;

    public abstract void addInterest();

}

AccountNumber.java

//This is the class with a function that automatically generates a unique bank account number
public class AccountNumber {
    static int accountNo = 100000;
    public int getNewAccountNo(){
        return ++accountNo;
    }
}

InsufficientBalanceException.java

//This is the class to create the exception for Insufficient balance message
public class InsufficientBalanceException extends Exception {
    public InsufficientBalanceException(String cause){
        super(cause);
    }
}

CheckingAccount.java

import java.util.ArrayList;

//This is the class for the Checking Account
public class CheckingAccount extends AbstractAccount{

    //This is the constructor
    public CheckingAccount(String holderNames, double initialBalance) {
        super(holderNames,initialBalance);
    }

    //This method returns the account number
    @Override
    protected int getAccountNo() {
        return super.accountNo;
    }

    //This method helps to retrieve the names of all the account holder names associated with the account
    @Override
    protected ArrayList<String> getHolderNames(){
        return super.holderNames;
    }

    //This method helps to retrieve the balance.
    @Override
    protected double getBalance() {
        return super.balance;
    }

    //This method helps to add a new account holder name to the account
    @Override
    protected void addNewAccountHolder(String holderName){
        super.holderNames.add(holderName);
    }

    //This method helps to deposit some amount to the account
    @Override
    public void deposit(double depAmount){
        super.balance+=depAmount;
        System.out.println("Deposited : $"+depAmount);
    }

    //This method helps to withdraw some amount from the account and throws an exception is the balance falls below $0
    @Override
    public void withdraw(double amount) {
        if(amount<=super.balance){
            super.balance-=amount;
            System.out.println("Withdrawn : $"+amount);
        }
        else{
            try {
                throw new InsufficientBalanceException("Error...Insufficient balance!");
            } catch (InsufficientBalanceException e) {
                e.printStackTrace();
            }
        }
    }

    //This method helps to add the interest to the balance
    @Override
    public void addInterest(){
        double interest = super.balance*0.01;
        super.balance=super.balance + interest;
        System.out.println("Interest Added @0.01 : $"+interest);
    }
}

SavingsAccount.java

import java.util.ArrayList;

//This is the class for the Savings Account
public class SavingsAccount extends AbstractAccount{
    //This is the constructor
    public SavingsAccount(String holderNames, double initialBalance) {
        super(holderNames, initialBalance);
        if(initialBalance<100){
            try {
                throw new InsufficientBalanceException("Error..Savings Account requires a minimum initial deposit of $100");
            } catch (InsufficientBalanceException e) {
                e.printStackTrace();
            }
        }
    }

    //This method returns the account number
    @Override
    protected int getAccountNo() {
        return super.accountNo;
    }

    //This method helps to retrieve the names of all the account holder names associated with the account
    @Override
    protected ArrayList<String> getHolderNames(){
        return super.holderNames;
    }

    //This method helps to retrieve the balance.
    @Override
    protected double getBalance() {
        return super.balance;
    }

    //This method helps to add a new account holder name to the account
    @Override
    protected void addNewAccountHolder(String holderName){
        super.holderNames.add(holderName);
    }

    //This method helps to deposit some amount to the account
    @Override
    public void deposit(double depAmount){
        super.balance+=depAmount;
        System.out.println("Deposited : $"+depAmount);
    }

    //This method helps to withdraw some amount from the account and throws an exception is the balance falls below $100
    @Override
    public void withdraw(double amount) {
        if(amount+100<=super.balance){
            super.balance-=amount;
            System.out.println("Withdrawn : $"+amount);
        }
        else{
            try {
                throw new InsufficientBalanceException("Error...Insufficient balance!");
            } catch (InsufficientBalanceException e) {
                e.printStackTrace();
            }
        }
    }

    //This method helps to add the interest to the balance
    @Override
    public void addInterest(){
        double interest;
        float rate;
        if(super.balance<2000){
            interest = super.balance*0.01;
            rate = 0.01f;
        }else if(super.balance>=2000 && super.balance<12000){
            interest = super.balance*0.05;
            rate = 0.05f;
        }else{
            interest = super.balance*0.1;
            rate = 0.1f;
        }
        super.balance = super.balance+interest;
        System.out.println("Interest Added @"+rate+" : $"+interest);
    }

}

BankAccountDemo.java:

//This is the main driver class and this demonstrates the implementation of banking system created.
public class BankAccountDemo {
    public static void main(String[] args) {
        //for Julio Perez' account
        AbstractAccount account1 = new CheckingAccount("Julio Perez",0);
        System.out.println("Your account Number is : "+ account1.getAccountNo());
        account1.deposit(1500);
        System.out.println("Account Balance : $"+account1.getBalance());
        account1.withdraw(150);
        System.out.println("Account Balance : $"+account1.getBalance());
        account1.addInterest();
        System.out.println("Account Balance : $"+account1.getBalance());
        account1.withdraw(750);
        System.out.println("Account Balance : $"+account1.getBalance());
        account1.addInterest();
        System.out.println("Account Balance : $"+account1.getBalance());
        System.out.println();
        //for Sasha Ivanov' account
        AbstractAccount account2 = new SavingsAccount("Sasha Ivanov",600);
        System.out.println("Your account Number is : "+ account2.getAccountNo());
        System.out.println("Account Balance : $"+account2.getBalance());
        account2.addInterest();
        System.out.println("Account Balance : $"+account2.getBalance());
        account2.deposit(150);
        System.out.println("Account Balance : $"+account2.getBalance());
        account2.addInterest();
        System.out.println("Account Balance : $"+account2.getBalance());
        account2.withdraw(600);
        System.out.println("Account Balance : $"+account2.getBalance());

    }
}

OUTPUT: