Account.java

import java.util.ArrayList;

/**
 * The Account class represents a basic bank account.
 * It demonstrates the OOP concept of Encapsulation by keeping fields private
 * and providing public getter and setter methods, as well as controlled transactional methods.
 */
public class Account {
    // Private variables (Encapsulation)
    private String accountNumber;
    private String accountHolderName;
    private double balance;
    private ArrayList<String> transactionHistory;

    // Overloaded Constructor 1: Account with initial balance
    public Account(String accountNumber, String accountHolderName, double initialBalance) {
        this.accountNumber = accountNumber;
        this.accountHolderName = accountHolderName;
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        } else {
            this.balance = 0;
            System.out.println("Initial balance cannot be negative. Setting balance to 0.0");
        }
        this.transactionHistory = new ArrayList<>();
        // Record initial deposit in transaction history
        recordTransaction("Account created with initial balance: Rs. " + this.balance);
    }

    // Overloaded Constructor 2: Account with zero initial balance (Constructor Overloading)
    public Account(String accountNumber, String accountHolderName) {
        this(accountNumber, accountHolderName, 0.0);
    }

    // Getter for Account Number
    public String getAccountNumber() {
        return accountNumber;
    }

    // Getter for Account Holder Name
    public String getAccountHolderName() {
        return accountHolderName;
    }

    // Setter for Account Holder Name (Encapsulation)
    public void setAccountHolderName(String accountHolderName) {
        this.accountHolderName = accountHolderName;
    }

    // Getter for Balance
    public double getBalance() {
        return balance;
    }

    // Internal helper to update balance and record transaction
    protected void setBalance(double balance) {
        this.balance = balance;
    }

    // Helper method to record transactions in ArrayList
    protected void recordTransaction(String details) {
        transactionHistory.add(details);
    }

    /**
     * Deposits a specified amount into the account.
     * @param amount The amount to deposit.
     */
    public void deposit(double amount) {
        if (amount <= 0) {
            System.out.println("Error: Deposit amount must be positive.");
            return;
        }
        this.balance += amount;
        String transactionDetails = "Deposited: Rs. " + amount + " | Current Balance: Rs. " + this.balance;
        recordTransaction(transactionDetails);
        System.out.println("Successfully deposited Rs. " + amount);
    }

    /**
     * Withdraws a specified amount from the account.
     * Performs validation on the amount and checks for sufficient balance.
     * @param amount The amount to withdraw.
     */
    public void withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("Error: Withdrawal amount must be positive.");
            return;
        }
        if (amount > this.balance) {
            System.out.println("Error: Insufficient Balance. Current balance: Rs. " + this.balance);
            recordTransaction("Failed Withdrawal: Rs. " + amount + " (Insufficient Balance)");
            return;
        }
        this.balance -= amount;
        String transactionDetails = "Withdrew: Rs. " + amount + " | Current Balance: Rs. " + this.balance;
        recordTransaction(transactionDetails);
        System.out.println("Successfully withdrew Rs. " + amount);
    }

    /**
     * Displays the current account details and balance.
     */
    public void displayBalance() {
        System.out.println("\n--- Account Balance ---");
        System.out.println("Account Number: " + accountNumber);
        System.out.println("Account Holder: " + accountHolderName);
        System.out.println("Current Balance: Rs. " + balance);
        System.out.println("-----------------------");
    }

    /**
     * Displays all transaction logs stored in the ArrayList.
     */
    public void showTransactionHistory() {
        System.out.println("\n--- Transaction History for Account " + accountNumber + " ---");
        if (transactionHistory.isEmpty()) {
            System.out.println("No transactions recorded yet.");
        } else {
            for (int i = 0; i < transactionHistory.size(); i++) {
                System.out.println((i + 1) + ". " + transactionHistory.get(i));
            }
        }
        System.out.println("-------------------------------------------------------");
    }
}

/**
 * SavingsAccount subclass demonstrating Inheritance and Method Overriding.
 * It extends the base class Account and adds a minimum balance requirement
 * and interest calculation functionality.
 */
class SavingsAccount extends Account {
    private double interestRate; // e.g., 0.03 for 3%
    private static final double MINIMUM_BALANCE = 500.0; // Savings accounts must maintain Rs. 500

    public SavingsAccount(String accountNumber, String accountHolderName, double initialBalance, double interestRate) {
        // Calling base class constructor
        super(accountNumber, accountHolderName, initialBalance);
        this.interestRate = interestRate;
        // Verify minimum balance constraint on creation
        if (initialBalance < MINIMUM_BALANCE) {
            System.out.println("Warning: Savings accounts should maintain a minimum balance of Rs. " + MINIMUM_BALANCE);
        }
    }

    // Overloaded constructor for SavingsAccount with default 3.5% interest rate
    public SavingsAccount(String accountNumber, String accountHolderName, double initialBalance) {
        this(accountNumber, accountHolderName, initialBalance, 0.035);
    }

    // Getter for interest rate
    public double getInterestRate() {
        return interestRate;
    }

    // Method Overriding: Overrides withdraw() to enforce minimum balance rule
    @Override
    public void withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("Error: Withdrawal amount must be positive.");
            return;
        }
        
        // Enforce minimum balance after withdrawal
        if (getBalance() - amount < MINIMUM_BALANCE) {
            System.out.println("Error: Insufficient Balance. A minimum balance of Rs. " + MINIMUM_BALANCE + " must be maintained.");
            System.out.println("Current Balance: Rs. " + getBalance() + " | Maximum allowed withdrawal: Rs. " + (getBalance() - MINIMUM_BALANCE));
            recordTransaction("Failed Withdrawal: Rs. " + amount + " (Enforced Minimum Balance constraint)");
            return;
        }
        
        // Use base class setBalance & recordTransaction methods
        setBalance(getBalance() - amount);
        String transactionDetails = "Withdrew (Savings): Rs. " + amount + " | Current Balance: Rs. " + getBalance();
        recordTransaction(transactionDetails);
        System.out.println("Successfully withdrew Rs. " + amount + " from Savings Account.");
    }

    /**
     * Calculates and applies interest to the balance.
     * Demonstrates an operation specific to Savings Accounts.
     */
    public void applyInterest() {
        double interest = getBalance() * interestRate;
        if (interest > 0) {
            setBalance(getBalance() + interest);
            String transactionDetails = "Interest Applied (" + (interestRate * 100) + "%): Rs. " + interest + " | Current Balance: Rs. " + getBalance();
            recordTransaction(transactionDetails);
            System.out.println("Successfully applied interest of Rs. " + interest);
        } else {
            System.out.println("No interest applied (balance is 0).");
        }
    }

    // Method Overriding: Overrides displayBalance() to show additional details
    @Override
    public void displayBalance() {
        super.displayBalance();
        System.out.println("Account Type: Savings Account");
        System.out.println("Interest Rate: " + (interestRate * 100) + "% per annum");
        System.out.println("Minimum Balance Required: Rs. " + MINIMUM_BALANCE);
        System.out.println("-----------------------");
    }
}