Name: Dhruv Bhalani
UID: 2024300019
Experiment No. 9
AIM: To handle the errors in Java
Program 1
PROBLEM There is an abstract class Account
STATEMENT :
Attribute:-
● Name
● Balance
● Acc_No
Method:-
● Deposit - abstract method
● withdraw - abstract method
● display - abstract method
Saving Account inherits the Account class and provides the implementation
for the methods accordingly
Saving Account class Attribute:-
● interestRate
● minBalance
Method
● addInterest: handle Arithmetic Exception
● transfer():
Note:
● Balance cannot be less than 0.
● In a Saving account if minBalance is set then for that the balance
cannot go less than that amount. If it goes, an error must be shown.
● let the user deposit to or withdraw from the account. For each
transaction, a message is displayed to indicate the status of the
transaction: successful or failed. In case of failure, the failure
reason is reported.
● The possible Exceptions are negative-amount-exception (in both
deposit and withdraw transaction) and insufficient-amount-
exception ( in withdraw transaction).
For the above scenario write an interactive program in Java. Also, show
output for different use cases.
PROGRAM: import java.util.Scanner;
class NegativeAmountException extends Exception {
public NegativeAmountException(String message) {
super(message);
}
}
class InsufficientAmountException extends Exception {
public InsufficientAmountException(String message) {
super(message);
}
}
abstract class Account {
protected String name;
protected double balance;
protected String accNo;
public Account(String name, double balance, String accNo) {
this.name = name;
this.balance = balance;
this.accNo = accNo;
}
abstract void deposit(double amount) throws
NegativeAmountException;
abstract void withdraw(double amount) throws
NegativeAmountException, InsufficientAmountException;
abstract void display();
}
class SavingAccount extends Account {
private double interestRate;
private double minBalance;
public SavingAccount(String name, double balance, String accNo,
double interestRate, double minBalance) {
super(name, balance, accNo);
this.interestRate = interestRate;
this.minBalance = minBalance;
}
@Override
void deposit(double amount) throws NegativeAmountException {
if (amount < 0)
throw new NegativeAmountException("Deposit failed: Amount
cannot be negative.");
balance += amount;
System.out.println("Deposit successful. Current Balance: " +
balance);
}
@Override
void withdraw(double amount) throws NegativeAmountException,
InsufficientAmountException {
if (amount < 0)
throw new NegativeAmountException("Withdraw failed:
Amount cannot be negative.");
if (balance - amount < minBalance)
throw new InsufficientAmountException("Withdraw failed:
Balance would go below minimum allowed (" + minBalance + ")");
balance -= amount;
System.out.println("Withdraw successful. Current Balance: " +
balance);
}
public void addInterest() {
try {
double interest = balance * (interestRate / 100);
balance += interest;
System.out.println("Interest added successfully. New Balance: "
+ balance);
} catch (ArithmeticException e) {
System.out.println("Arithmetic Exception occurred while
adding interest.");
}
}
public void transfer(SavingAccount toAccount, double amount) {
try {
this.withdraw(amount);
toAccount.deposit(amount);
System.out.println("Transfer successful to account " +
toAccount.accNo);
} catch (Exception e) {
System.out.println("Transfer failed: " + e.getMessage());
}
}
@Override
void display() {
System.out.println("Account No: " + accNo);
System.out.println("Name: " + name);
System.out.println("Balance: " + balance);
System.out.println("Interest Rate: " + interestRate);
System.out.println("Minimum Balance: " + minBalance);
}
}
class BankSystem {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
SavingAccount acc1 = new SavingAccount("Alice", 5000, "A101",
4.5, 1000);
SavingAccount acc2 = new SavingAccount("Bob", 3000, "B202",
4.0, 500);
System.out.println("Welcome to Bank System");
int choice;
do {
System.out.println("\n1. Display Account Info");
System.out.println("2. Deposit");
System.out.println("3. Withdraw");
System.out.println("4. Add Interest");
System.out.println("5. Transfer");
System.out.println("6. Exit");
System.out.print("Choose an option: ");
choice = sc.nextInt();
SavingAccount currentAcc = acc1;
switch (choice) {
case 1:
currentAcc.display();
break;
case 2:
System.out.print("Enter deposit amount: ");
double dep = sc.nextDouble();
try {
currentAcc.deposit(dep);
} catch (NegativeAmountException e) {
System.out.println(e.getMessage());
}
break;
case 3:
System.out.print("Enter withdraw amount: ");
double wdr = sc.nextDouble();
try {
currentAcc.withdraw(wdr);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 4:
currentAcc.addInterest();
break;
case 5:
System.out.print("Enter amount to transfer to Bob: ");
double amt = sc.nextDouble();
currentAcc.transfer(acc2, amt);
break;
case 6:
System.out.println("Thank you for using Bank System!");
break;
default:
System.out.println("Invalid option.");
}
} while (choice != 6);
sc.close();
}
}
RESULT:
CONCLUSION:
This Java program demonstrates the use of abstract classes and
inheritance to model a simple banking system with SavingAccount
functionality. It effectively handles user interactions, performs transactions
like deposit, withdraw, add interest, and transfer, and showcases robust
exception handling using multiple catch blocks for
ArrayIndexOutOfBoundsException, NullPointerException, and
ArithmeticException. Through this, it illustrates the importance of
defensive programming and structured object-oriented design in real-world
applications.
