Guided Exercise: Account Management System – Inheritance in Action

[akash-coded]

Logical follow-up of the problem number 2,3,4 of discussion #8

Instructions for the Trainees:

• You will create a single Java file named BankingSystemDemo.java.
• This file will contain multiple classes. Only the BankingSystemDemo class (which includes the main method) should be public. Other classes should have default (package-private) access.
• Pay close attention to the hints provided for coding best practices and naming conventions.
• Your goal is to write clean, readable, and well-commented code as if it were part of a production system.

---

Single-File Core Java OOP Exercise: JPMC Branch Operations Simulator

Objective: To master class inheritance (single and multi-level), method overriding, constructor chaining, polymorphism, and apply Java coding best practices within a single-file structure, simulating operations at a bank branch.

Scenario:

Welcome to the JPMC Digital Branch! Today, you'll be setting up the core account management system. We need to handle various account types with specific features. All your code will reside in one file, BankingSystemDemo.java. Let's begin!

// BankingSystemDemo.java

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;

// HINT: Naming Convention - Class names should be in PascalCase.
// HINT: Best Practice - For larger projects, each public class resides in its own .java file.
// For this exercise, we'll use package-private (default access) for helper classes within this single file.

//--------------------------------------------------------------------------------
// Phase 1: The Foundation - Account Class
//--------------------------------------------------------------------------------
class Account {
    // HINT: Best Practice - Encapsulation: Data members should generally be private.
    private String accountNumber;
    private String accountHolderName;
    protected double balance; // Protected to allow direct access by subclasses if absolutely needed, though getters/setters are often better.
    private LocalDate accountOpeningDate;

    // HINT: Naming Convention - Use camelCase for variable and method names.
    // HINT: Best Practice - Constructors are used to initialize objects. Ensure valid initial states.
    public Account(String accountNumber, String accountHolderName, double initialBalance) {
        if (accountNumber == null || accountNumber.trim().isEmpty()) {
            throw new IllegalArgumentException("Account number cannot be null or empty.");
        }
        if (accountHolderName == null || accountHolderName.trim().isEmpty()) {
            throw new IllegalArgumentException("Account holder name cannot be null or empty.");
        }
        // HINT: Best Practice - Validate inputs to prevent invalid object states.
        if (initialBalance < 0) {
            throw new IllegalArgumentException("Initial balance cannot be negative. Account: " + accountNumber);
        }
        this.accountNumber = accountNumber;
        this.accountHolderName = accountHolderName;
        this.balance = initialBalance;
        this.accountOpeningDate = LocalDate.now(); // Automatically set to current date
        System.out.println("Account " + accountNumber + " created for " + accountHolderName + " on " + accountOpeningDate.format(DateTimeFormatter.ISO_DATE) + ".");
    }

    // --- TODO: TASK 1.1: Implement debit method ---
    /**
     * Withdraws money from the account.
     * Ensure the debit amount does not exceed the balance.
     *
     * @param amount The amount to withdraw. Must be positive.
     * @return true if debit is successful, false otherwise.
     * HINT: Best Practice - Methods should have clear responsibilities.
     * HINT: Javadoc - Document what the method does, its parameters (@param), and what it returns (@return).
     */
    public boolean debit(double amount) {
        // Your code here
        // Validate 'amount' (must be positive).
        // Check if 'amount' exceeds 'balance'.
        // If exceeds, print "Debit amount ₹%.2f exceeded account balance for account %s. Current balance: ₹%.2f%n" and return false.
        // Otherwise, deduct and print "Debit successful for account %s. Amount: ₹%.2f. New balance: ₹%.2f%n", then return true.
        if (amount <= 0) {
            System.out.printf("Debit amount must be positive for account %s.%n", accountNumber);
            return false;
        }
        if (amount > balance) {
            System.out.printf("Debit amount ₹%.2f exceeded account balance for account %s. Current balance: ₹%.2f%n", amount, accountNumber, balance);
            return false;
        }
        balance -= amount;
        System.out.printf("Debit successful for account %s. Amount: ₹%.2f. New balance: ₹%.2f%n", accountNumber, amount, balance);
        return true;
    }

    // --- TODO: TASK 1.2: Implement credit method ---
    /**
     * Deposits money into the account.
     *
     * @param amount The amount to deposit. Must be positive.
     * @return true if credit is successful, false otherwise.
     */
    public boolean credit(double amount) {
        // Your code here
        // Validate 'amount' (must be positive).
        // If not, print "Credit amount must be positive for account %s.%n" and return false.
        // Otherwise, add to balance and print "Credit successful for account %s. Amount: ₹%.2f. New balance: ₹%.2f%n", then return true.
        if (amount <= 0) {
            System.out.printf("Credit amount must be positive for account %s.%n", accountNumber);
            return false;
        }
        balance += amount;
        System.out.printf("Credit successful for account %s. Amount: ₹%.2f. New balance: ₹%.2f%n", accountNumber, amount, balance);
        return true;
    }

    public double getBalance() {
        return this.balance;
    }

    public String getAccountNumber() {
        return this.accountNumber;
    }

    public String getAccountHolderName() {
        return this.accountHolderName;
    }

    // HINT: Best Practice - Provide a readable string representation of your object.
    /**
     * Returns a string representation of the account details.
     * @return Formatted string with account details.
     */
    public String getAccountDetails() {
        return String.format("Account Type: Generic Account%n" +
                             "Account Number: %s%n" +
                             "Account Holder: %s%n" +
                             "Balance: ₹%.2f%n" +
                             "Opened On: %s%n",
                             accountNumber, accountHolderName, balance, accountOpeningDate.format(DateTimeFormatter.ISO_DATE));
    }
}

//--------------------------------------------------------------------------------
// Phase 2: Specialization - SavingsAccount (Inherits from Account)
//--------------------------------------------------------------------------------
// --- TODO: TASK 2.1: Define SavingsAccount class ---
class SavingsAccount extends Account {
    private double interestRate; // e.g., 0.03 for 3%
    private double minimumBalance;

    // HINT: Best Practice - Use 'super()' to call the constructor of the parent class. It must be the first statement.
    public SavingsAccount(String accountNumber, String accountHolderName, double initialBalance, double interestRate, double minimumBalance) {
        super(accountNumber, accountHolderName, initialBalance); // Call to Account constructor
        // Validate interestRate (e.g., 0.0 to 0.20 for 0% to 20%)
        // Validate minimumBalance (e.g., non-negative)
        if (interestRate < 0.0 || interestRate > 0.20) {
            throw new IllegalArgumentException("Interest rate must be between 0.0 and 0.20 for account " + accountNumber);
        }
        if (minimumBalance < 0) {
            throw new IllegalArgumentException("Minimum balance cannot be negative for account " + accountNumber);
        }
        this.interestRate = interestRate;
        this.minimumBalance = minimumBalance;
        System.out.println("Savings Account " + accountNumber + " configured with interest rate " + (interestRate*100) + "% and minimum balance ₹" + minimumBalance);
    }

    // --- TODO: TASK 2.2: Override debit method ---
    /**
     * Withdraws money, ensuring balance doesn't drop below minimumBalance.
     * HINT: Use @Override annotation when overriding methods.
     */
    @Override
    public boolean debit(double amount) {
        // Your code here
        // Validate 'amount' (must be positive).
        // Check if (balance - amount) < minimumBalance.
        // If so, print "Debit not allowed for account %s: Would drop balance below minimum ₹%.2f. Current balance: ₹%.2f%n" and return false.
        // Otherwise, call the parent class's debit method: super.debit(amount).
        if (amount <= 0) {
            System.out.printf("Debit amount must be positive for account %s.%n", getAccountNumber());
            return false;
        }
        if ((balance - amount) < minimumBalance) {
            System.out.printf("Debit not allowed for account %s: Would drop balance below minimum ₹%.2f. Current balance: ₹%.2f%n", getAccountNumber(), minimumBalance, balance);
            return false;
        }
        return super.debit(amount); // Calls Account.debit()
    }

    // --- TODO: TASK 2.3: Implement applyInterest method ---
    /**
     * Calculates and applies simple annual interest to the balance.
     */
    public void applyInterest() {
        // Your code here
        // Calculate interest: balance * interestRate
        // Credit this interest to the account using the credit() method.
        // Print a message: "Interest of ₹%.2f applied to Savings Account %s. New balance: ₹%.2f%n"
        double interestEarned = balance * interestRate;
        if (interestEarned > 0) {
            System.out.printf("Applying interest of ₹%.2f to Savings Account %s...%n", interestEarned, getAccountNumber());
            credit(interestEarned); // Uses the credit method to update balance and print message
            // The credit method already prints a success message. If you want a specific one for interest:
            // System.out.printf("Interest application complete. New balance for account %s: ₹%.2f%n", getAccountNumber(), balance);
        } else {
            System.out.printf("No interest to apply for Savings Account %s at this time.%n", getAccountNumber());
        }
    }

    // --- TODO: TASK 2.4: Override getAccountDetails method ---
    /**
     * Appends SavingsAccount specific details to the base account details.
     * HINT: Use super.getAccountDetails() to get details from the parent.
     */
    @Override
    public String getAccountDetails() {
        // Your code here
        // Start with super.getAccountDetails().
        // Append "Account Type: Savings Account%n", "Interest Rate: %.2f%%%n", "Minimum Balance: ₹%.2f%n".
        // (Note: The base getAccountDetails already includes "Account Type: Generic Account". You might want to make the base method's type more generic or change this override).
        // Let's adjust: The base should be generic, or this should replace the type.
        // For now, let's assume base is generic and we add specifics.
        // A better way:
        // return String.format("Account Type: Savings Account%n" + // Overrides the type line
        //                      "Account Number: %s%n" +
        //                      "Account Holder: %s%n" +
        //                      "Balance: ₹%.2f%n" +
        //                      "Opened On: %s%n" + // Assuming accountOpeningDate is private in Account, and no getter. We'll need to fix Account or call super.
        //                      "Interest Rate: %.2f%%%n" +
        //                      "Minimum Balance: ₹%.2f%n",
        //                      getAccountNumber(), getAccountHolderName(), getBalance(), /* need opening date */, interestRate * 100, minimumBalance);
        // Correct approach:
        return super.getAccountDetails().replace("Account Type: Generic Account", "Account Type: Savings Account") +
               String.format("Interest Rate: %.2f%%%nMinimum Balance: ₹%.2f%n", interestRate * 100, minimumBalance);

    }
}

//--------------------------------------------------------------------------------
// Phase 3: Multi-Level Inheritance - SalaryAccount (Inherits from SavingsAccount)
//--------------------------------------------------------------------------------
// --- TODO: TASK 3.1: Define SalaryAccount class ---
class SalaryAccount extends SavingsAccount {
    private static final double DEFAULT_SALARY_ACC_MIN_BALANCE = 0.0;
    private boolean firstSalaryCredited; // A simple flag for potential benefits

    // HINT: A SalaryAccount is a specialized SavingsAccount, often with no minimum balance.
    public SalaryAccount(String accountNumber, String accountHolderName, double initialBalance, double interestRate) {
        // Your code here
        // Call super constructor for SavingsAccount. Pass DEFAULT_SALARY_ACC_MIN_BALANCE for minimumBalance.
        // Initialize firstSalaryCredited to false.
        super(accountNumber, accountHolderName, initialBalance, interestRate, DEFAULT_SALARY_ACC_MIN_BALANCE);
        this.firstSalaryCredited = false;
        System.out.println("Salary Account " + accountNumber + " configured. Welcome to hassle-free banking!");
    }

    // --- TODO: TASK 3.2: Implement processSalaryCredit method ---
    public void processSalaryCredit(double salaryAmount) {
        // Your code here
        // Credit the salaryAmount using the credit() method.
        // Set firstSalaryCredited to true.
        // Print: "Salary of ₹%.2f credited to Salary Account %s.%n"
        System.out.printf("Processing salary credit of ₹%.2f for account %s...%n", salaryAmount, getAccountNumber());
        if(credit(salaryAmount)) {
            this.firstSalaryCredited = true;
            // The credit method already prints a general success message.
            // System.out.printf("Salary of ₹%.2f credited to Salary Account %s.%n", salaryAmount, getAccountNumber()); // Redundant if credit() is verbose
        }
    }

    // --- TODO: TASK 3.3: Override getAccountDetails method ---
    @Override
    public String getAccountDetails() {
        // Your code here
        // Start with super.getAccountDetails() (which comes from SavingsAccount).
        // Append "Special Feature: Zero Minimum Balance (Salary Account)%n"
        // Append "Initial Salary Credited: %s%n"
        return super.getAccountDetails().replace("Account Type: Savings Account", "Account Type: Salary Account") +
               String.format("Special Feature: Zero Minimum Balance (Salary Account)%nInitial Salary Credited: %s%n", firstSalaryCredited ? "Yes" : "No");
    }
}

//--------------------------------------------------------------------------------
// Phase 4: Another Branch - CurrentAccount (Inherits from Account)
//--------------------------------------------------------------------------------
// --- TODO: TASK 4.1: Define CurrentAccount class ---
class CurrentAccount extends Account {
    private double overdraftLimit;
    private String businessName;

    public CurrentAccount(String accountNumber, String accountHolderName, double initialBalance, String businessName, double overdraftLimit) {
        super(accountNumber, accountHolderName, initialBalance);
        // Validate businessName (not null/empty)
        // Validate overdraftLimit (non-negative)
        if (businessName == null || businessName.trim().isEmpty()) {
            throw new IllegalArgumentException("Business name cannot be null or empty for Current Account " + accountNumber);
        }
        if (overdraftLimit < 0) {
            throw new IllegalArgumentException("Overdraft limit cannot be negative for Current Account " + accountNumber);
        }
        this.businessName = businessName;
        this.overdraftLimit = overdraftLimit;
        System.out.println("Current Account " + accountNumber + " for " + businessName + " configured with overdraft limit ₹" + overdraftLimit);
    }

    // --- TODO: TASK 4.2: Override debit method ---
    @Override
    public boolean debit(double amount) {
        // Your code here
        // Validate 'amount' (must be positive).
        // Allow debiting even if (balance - amount) goes negative,
        // as long as (balance - amount) >= -overdraftLimit.
        // If (balance - amount) < -overdraftLimit, print "Debit ₹%.2f exceeds overdraft limit for Current Account %s. Max Overdraft: ₹%.2f Current Balance: ₹%.2f%n" and return false.
        // Otherwise, update balance (it can go negative) and print "Debit successful for Current Account %s. Amount: ₹%.2f. New balance: ₹%.2f (Overdraft available: ₹%.2f)%n". Return true.
        if (amount <= 0) {
            System.out.printf("Debit amount must be positive for account %s.%n", getAccountNumber());
            return false;
        }
        if ((balance - amount) < -overdraftLimit) {
            System.out.printf("Debit ₹%.2f exceeds overdraft limit for Current Account %s. Max Overdraft: ₹%.2f Current Balance: ₹%.2f%n",
                              amount, getAccountNumber(), overdraftLimit, balance);
            return false;
        }
        balance -= amount;
        System.out.printf("Debit successful for Current Account %s. Amount: ₹%.2f. New balance: ₹%.2f (Remaining Overdraft: ₹%.2f)%n",
                          getAccountNumber(), amount, balance, overdraftLimit + balance); // overdraftLimit + balance gives remaining OD if balance is negative
        return true;
    }
    
    public void setOverdraftLimit(double newOverdraftLimit) {
        if (newOverdraftLimit < 0) {
            System.out.println("New overdraft limit cannot be negative. Request denied for account " + getAccountNumber());
            return;
        }
        this.overdraftLimit = newOverdraftLimit;
        System.out.printf("Overdraft limit for account %s updated to ₹%.2f%n", getAccountNumber(), this.overdraftLimit);
    }

    // --- TODO: TASK 4.3: Override getAccountDetails method ---
    @Override
    public String getAccountDetails() {
        // Your code here
        // Similar to SavingsAccount, call super and append/modify.
        return super.getAccountDetails().replace("Account Type: Generic Account", "Account Type: Current Account") +
               String.format("Business Name: %s%nOverdraft Limit: ₹%.2f%n", businessName, overdraftLimit);
    }
}


//--------------------------------------------------------------------------------
// Phase 5: The Main Show - JPMC Branch Operations (Driver Class)
//--------------------------------------------------------------------------------
public class BankingSystemDemo {
    public static void main(String[] args) {
        System.out.println("--- JPMC Digital Branch Operations Initializing ---");
        // HINT: Best Practice - Use a List or other collections to manage multiple objects.
        List<Account> allAccounts = new ArrayList<>();

        // --- TODO: TASK 5.1: Simulate Customer 1 - Savings Account ---
        System.out.println("\n--- Customer 1: Ms. Priya Sharma (Savings Account) ---");
        try {
            // Create a SavingsAccount for Priya: ACCS001, Priya Sharma, initial balance 5000, interest 2.5%, min balance 1000.
            // Add to allAccounts list.
            // Credit 2000.
            // Debit 500.
            // Attempt to debit 6000 (should fail due to min balance or insufficient funds).
            // Attempt to debit 4500 (should fail due to min balance).
            // Debit 3500 (should be okay).
            // Apply interest.
            // Print final account details.
            SavingsAccount priyaSavings = new SavingsAccount("ACCS001", "Priya Sharma", 5000.00, 0.025, 1000.00);
            allAccounts.add(priyaSavings);

            priyaSavings.credit(2000.00);
            priyaSavings.debit(500.00);
            priyaSavings.debit(6000.00); // Expected to fail (insufficient overall)
            priyaSavings.debit(4500.00); // 7000-500 = 6500. 6500 - 4500 = 2000. This might be ok if min balance logic is hit first.
                                        // Ah, 6500 - 4500 = 2000. This is >= 1000. So this should be fine.
                                        // Let's make it fail min balance: debit 5600 (6500-5600 = 900, <1000)
            priyaSavings.debit(5600.00); // Expected to fail (min balance)
            priyaSavings.debit(3500.00); // 6500 - 3500 = 3000. This should be OK.
            priyaSavings.applyInterest();
            System.out.println("\nFinal Details for Ms. Priya:");
            System.out.println(priyaSavings.getAccountDetails());

        } catch (IllegalArgumentException e) {
            System.err.println("Error creating account for Customer 1: " + e.getMessage());
        }

        // --- TODO: TASK 5.2: Simulate Customer 2 - Salary Account ---
        System.out.println("\n--- Customer 2: Mr. Rohan Verma (Salary Account) ---");
        try {
            // Create a SalaryAccount for Rohan: ACCSAL002, Rohan Verma, initial balance 1000, interest 1.5%.
            // Add to allAccounts list.
            // Process salary credit of 75000.
            // Debit 20000.
            // Debit 55000. // Balance should be 1000+75000-20000-55000 = 1000
            // Attempt to debit 1500 (should fail as it goes below default min balance of 0 from SavingsAccount definition - oh wait, SalaryAccount has 0 min balance. So this should pass!)
            // Debit 1000 (balance becomes 0).
            // Apply interest.
            // Print final account details.
            SalaryAccount rohanSalary = new SalaryAccount("ACSAL002", "Rohan Verma", 1000.00, 0.015);
            allAccounts.add(rohanSalary);

            rohanSalary.processSalaryCredit(75000.00);
            rohanSalary.debit(20000.00);
            rohanSalary.debit(55000.00);
            rohanSalary.debit(1500.00); // Will go to -500 if SavingsAccount's debit is not overridden properly by Salary OR if Salary uses Savings' debit logic directly with its own 0 min balance
                                        // The current SalaryAccount debit directly uses SavingsAccount debit. SavingsAccount debit checks its own minimumBalance.
                                        // SalaryAccount constructor sets minimumBalance to 0 for its SavingsAccount part. So, this debit of 1500 should be fine.
                                        // 1000+75000-20000-55000 = 1000. 1000 - 1500 = -500. This would only be okay if SalaryAccount overrides debit to allow overdraft, which it doesn't.
                                        // It will use SavingsAccount's debit, which checks against minimumBalance (0 for SalaryAccount).
                                        // So, 1000-1500=-500. Is -500 < 0 (SalaryAccount's minBalance via super call)? Yes. So SavingsAccount's debit should prevent this.
                                        // Let's re-verify SavingsAccount debit: if (balance - amount) < minimumBalance -> fail. Here: (1000-1500) < 0 -> -500 < 0 -> True -> fail. Correct.
            rohanSalary.debit(1000.00); // Balance will be 0.
            rohanSalary.applyInterest(); // Interest on 0 balance will be 0.
            System.out.println("\nFinal Details for Mr. Rohan:");
            System.out.println(rohanSalary.getAccountDetails());

        } catch (IllegalArgumentException e) {
            System.err.println("Error creating account for Customer 2: " + e.getMessage());
        }

        // --- TODO: TASK 5.3: Simulate Customer 3 - Current Account ---
        System.out.println("\n--- Customer 3: 'Innovate Solutions Ltd.' (Current Account) ---");
        try {
            // Create a CurrentAccount: ACCCUR003, Innovate Solutions Ltd., initial balance 50000, business name "Innovate Solutions Ltd.", overdraft 25000.
            // Add to allAccounts list.
            // Credit 30000.
            // Debit 70000 (goes into overdraft: 50k+30k-70k = 10k balance).
            // Debit 15000 (goes further into overdraft: 10k-15k = -5k balance).
            // Attempt to debit 25000 (should fail: -5k - 25k = -30k, which is > 25k overdraft limit).
            // Print final account details.
            CurrentAccount innovateBiz = new CurrentAccount("ACCCUR003", "Innovate Solutions Ltd. (Rep: Mr. CFO)", 50000.00, "Innovate Solutions Ltd.", 25000.00);
            allAccounts.add(innovateBiz);

            innovateBiz.credit(30000.00); // Bal: 80000
            innovateBiz.debit(70000.00); // Bal: 10000
            innovateBiz.debit(15000.00); // Bal: -5000 (Overdraft used: 5000)
            innovateBiz.debit(25000.00); // Current bal -5000. -5000 - 25000 = -30000. Overdraft limit is 25000. So -30000 is below -25000. Should fail.
            innovateBiz.setOverdraftLimit(30000); // Try increasing OD
            innovateBiz.debit(25000.00); // Now this should pass. Bal will be -30000.
            System.out.println("\nFinal Details for Innovate Solutions Ltd.:");
            System.out.println(innovateBiz.getAccountDetails());

        } catch (IllegalArgumentException e) {
            System.err.println("Error creating account for Customer 3: " + e.getMessage());
        }

        // --- TODO: TASK 5.4: Polymorphism & End of Day Summary ---
        System.out.println("\n\n--- End of Day Branch Summary ---");
        // HINT: Polymorphism - Iterate through the 'allAccounts' list (which contains Account type references).
        // Call getAccountDetails() on each. The correct version for each account type should be invoked.
        // Calculate and print the total balance held by the bank across all accounts (sum of getBalance()).
        // Find and print the name of the account holder with the highest balance.
        double totalBankBalance = 0;
        Account richestAccount = null;

        if (allAccounts.isEmpty()) {
            System.out.println("No accounts processed today.");
        } else {
            for (Account acc : allAccounts) {
                System.out.println("------------------------------------");
                System.out.println(acc.getAccountDetails()); // Polymorphic call
                totalBankBalance += acc.getBalance();
                if (richestAccount == null || acc.getBalance() > richestAccount.getBalance()) {
                    richestAccount = acc;
                }
            }
            System.out.println("------------------------------------");
            System.out.printf("%nTotal balance held by JPMC Digital Branch: ₹%.2f%n", totalBankBalance);
            if (richestAccount != null) {
                System.out.printf("Account with the highest balance: %s (%s) with ₹%.2f%n",
                                  richestAccount.getAccountHolderName(), richestAccount.getAccountNumber(), richestAccount.getBalance());
            }
        }

        System.out.println("\n--- JPMC Digital Branch Operations Concluded ---");


        // --- TODO: TASK 5.5: Discussion Points (Self-Reflection after coding) ---
        /*
         * 1.  Why is 'balance' in 'Account' marked 'protected' in this exercise? What are the pros/cons vs. 'private' with getters/setters for subclass modification?
         * 2.  Explain where `super()` was crucial in your constructors. What happens if you omit it?
         * 3.  How does `@Override` help? What if you misspelled a method you intended to override and didn't use `@Override`?
         * 4.  In Task 5.4, how does the line `System.out.println(acc.getAccountDetails());` demonstrate polymorphism?
         * 5.  Could the `Account` class be made `abstract`? What would be the implications? What method(s) might you declare `abstract`?
         * 6.  Think about Javadoc comments: For which elements (classes, methods, fields) are they most critical in a production environment?
         * 7.  Consider the `debit` method in `SavingsAccount`. It calls `super.debit()`. Could you have re-implemented the balance deduction logic entirely within `SavingsAccount.debit()`? What are the pros/cons of calling `super.debit()`?
         * 8.  If JPMC introduced a new "StudentAccount" with a withdrawal limit per transaction, how would you fit it into this hierarchy?
         */
    }
}

Key Areas for Trainees to Fill In (Marked with // --- TODO: ---)

1. Account Class:
   • debit(double amount) method logic.
   • credit(double amount) method logic.
   • (Javadoc comments are already prompted).
2. SavingsAccount Class:
   • Constructor implementation (calling super, validating new fields).
   • debit(double amount) override logic (checking minimumBalance, calling super.debit).
   • applyInterest() method logic.
   • getAccountDetails() override logic.
3. SalaryAccount Class:
   • Constructor implementation (calling super with specific minimumBalance).
   • processSalaryCredit(double salaryAmount) method logic.
   • getAccountDetails() override logic.
4. CurrentAccount Class:
   • Constructor implementation.
   • debit(double amount) override logic (handling overdraftLimit).
   • getAccountDetails() override logic.
5. BankingSystemDemo main method:
   • Instantiating objects for each customer scenario.
   • Performing the specified operations.
   • Implementing the "End of Day Summary" logic (iteration, polymorphism, total balance, richest account).
   • Reviewing the discussion points.