Reconsider the following examples mentioned below BankAccount.java NegativeStartingBalance.java AccountTest.java

First, modify the BankAccount class to include an additional field named interestRate of type double. Update the constructor accordingly. Recall the following cases of exceptions that can affect a bank account: A negative starting balance is passed to the constructor. A negative interest rate is passed to the constructor. A negative number is passed to the deposit method. A negative number is passed to the withdraw method. The amount passed to the withdraw method exceeds the accounts balance. In class, we only considered the first case. In this lab, you will create exceptions that represent the remaining 4 error conditions by extending the Exception class. Name your classes as follows: NegativeInterest.java NegativeDeposit.java NegativeWithdraw.java AmountWithdrawExceeds.java Write a driver program to test all your exception classes. Try out some scenarios that will throw exceptions.

BankAccount.java

/** The BankAccount class simulates a bank account. */

public class BankAccount { private double balance; // Account balance

/** This constructor sets the starting balance at 0.0. */

public BankAccount() { balance = 0.0; } /** This constructor sets the starting balance to the value passed as an argument. @param startBalance The starting balance. @exception NegativeStartingBalance When startBalance is negative. */

public BankAccount(double startBalance) throws NegativeStartingBalance { if (startBalance < 0) throw new NegativeStartingBalance(startBalance); balance = startBalance; }

/** This constructor sets the starting balance to the value in the String argument. @param str The starting balance, as a String. */

public BankAccount(String str) { balance = Double.parseDouble(str); }

/** The deposit method makes a deposit into the account. @param amount The amount to add to the balance field. */

public void deposit(double amount) { balance += amount; }

/** The deposit method makes a deposit into the account. @param str The amount to add to the balance field, as a String. */

public void deposit(String str) { balance += Double.parseDouble(str); }

/** The withdraw method withdraws an amount from the account. @param amount The amount to subtract from the balance field. */

public void withdraw(double amount) { balance -= amount; }

/** The withdraw method withdraws an amount from the account. @param str The amount to subtract from the balance field, as a String. */

public void withdraw(String str) { balance -= Double.parseDouble(str); }

/** The setBalance method sets the account balance. @param b The value to store in the balance field. */

public void setBalance(double b) { balance = b; }

/** The setBalance method sets the account balance. @param str The value, as a String, to store in the balance field. */

public void setBalance(String str) { balance = Double.parseDouble(str); } /** The getBalance method returns the account balance. @return The value in the balance field. */

public double getBalance() { return balance; } }

NegativeStartingBalance.java

/** NegativeStartingBalance exceptions are thrown by the BankAccount class when a negative starting balance is passed to the constructor. */

public class NegativeStartingBalance extends Exception { /** This constructor uses a generic error message. */

public NegativeStartingBalance() { super("Error: Negative starting balance"); }

/** This constructor specifies the bad starting balance in the error message. @param The bad starting balance. */

public NegativeStartingBalance(double amount) { super("Error: Negative starting balance: " + amount); } }

AccountTest.java

/** This program demonstrates how the BankAccount class constructor throws custom exceptions. */

public class AccountTest { public static void main(String [] args) { // Force a NegativeStartingBalance exception. try { BankAccount account = new BankAccount(-100.0); } catch(NegativeStartingBalance e) { System.out.println(e.getMessage()); } } }