Guided Exercise: Advanced Method Overriding - Customizing Account Services

[akash-coded]

Guided Exercise: Advanced Method Overriding - Customizing Account Services

Objective: To understand and implement method overriding in depth, providing specialized behaviors in subclasses for a common operation, and observe polymorphic behavior.

Scenario:

JPMC has decided to implement a system for applying monthly account service charges. However, these charges are not uniform. They vary based on the type of account:

• Standard Accounts (if any were to be created directly, though less common) might have a very basic or no charge.
• SavingsAccounts might be charged if their balance falls below certain thresholds relative to their minimum balance.
• SalaryAccounts, being premium, will have this charge waived.
• CurrentAccounts will have a fixed charge due to the nature of services they offer.

This requires each account type to handle the "apply service charge" operation in its own unique way, a perfect use case for method overriding.

Prerequisites:

• You should have the completed BankingSystemDemo.java file from the previous exercise.
• A basic understanding of what method overriding is: A subclass providing a specific implementation for a method that is already defined in its superclass.

Instructions:

You will modify the existing classes within your BankingSystemDemo.java file.

Task 1: Introduce a Generic Service Charge Method in the Account Class

1. Open your BankingSystemDemo.java file.
2. Navigate to the Account class.
3. Add a new public method with the following signature:

   /**
    * Applies a monthly service charge to the account.
    * This base implementation assumes no charge for a generic account
    * or a very minimal default behavior.
    * Subclasses are expected to override this for specific charge logic.
    * HINT: Javadoc explains the purpose and expected behavior, especially for overriding.
    */
   public void applyMonthlyServiceCharge() {
       // For a generic account, let's assume no service charge is applied by default.
       // Or, you could apply a nominal fee if it makes sense for a "base" account type.
       // For this exercise, let's just print a message for the base type.
       System.out.printf("No specific monthly service charge defined for generic Account %s.%n", getAccountNumber());
       // No change to balance in this base version.
   }

4. Explanation:
   • This method, applyMonthlyServiceCharge(), is defined in the base Account class. It provides a default behavior.
   • The intention is that subclasses (SavingsAccount, SalaryAccount, CurrentAccount) will override this method to implement their specific service charge rules.

Task 2: Override Service Charge Logic in SavingsAccount

1. Navigate to the SavingsAccount class.

2. Override the applyMonthlyServiceCharge() method.

   • Logic: If the balance is less than minimumBalance + 500 (or another threshold you define, e.g., minimumBalance * 1.2), a service charge of ₹50.00 should be debited. Otherwise, the charge is waived.
   • Use the @Override annotation.
   • Make sure to debit the amount from the balance only if the charge is applied and successful. You can use the existing debit() method, but be careful: the debit() method in SavingsAccount itself has minimum balance checks. For a service charge, you might want to bypass this specific minimumBalance check (i.e., a service charge can take you below minimumBalance, or up to it). For simplicity here, let's assume the service charge can reduce the balance, even if it slightly dips below the usual operational minimumBalance but not below zero. Or, more robustly, define a small, fixed charge that is applied if conditions are met and directly deduct it.
   • Print appropriate messages.

   // Inside SavingsAccount class
   @Override // HINT: Best Practice - Always use @Override to catch errors like misspelled method names.
   public void applyMonthlyServiceCharge() {
       System.out.printf("Evaluating monthly service charge for Savings Account %s...%n", getAccountNumber());
       double serviceCharge = 50.00;
       // Example condition: charge if balance is less than minimumBalance + 500 INR buffer
       boolean chargeApplicable = (getBalance() < (this.minimumBalance + 500.00)) && (getBalance() >= serviceCharge);
   
       if (chargeApplicable) {
           System.out.printf("Savings Account %s balance (₹%.2f) is low. Applying service charge of ₹%.2f.%n", getAccountNumber(), getBalance(), serviceCharge);
           // Directly deduct from balance for service charge, could bypass normal debit minimum balance rule for charges
           // Or use debit carefully. For this exercise, let's do a direct deduction for simplicity:
           if (balance >= serviceCharge) { // Ensure account can at least cover the charge
               balance -= serviceCharge; // Accessing 'balance' (protected in Account) directly
               System.out.printf("Service charge applied. New balance for %s: ₹%.2f%n", getAccountNumber(), balance);
           } else {
               System.out.printf("Service charge ₹%.2f cannot be applied. Insufficient funds in %s. Balance: ₹%.2f%n", serviceCharge, getAccountNumber(), balance);
           }
       } else {
           System.out.printf("Service charge waived for Savings Account %s. Balance (₹%.2f) is adequate.%n", getAccountNumber(), getBalance());
       }
   }

3. Explanation:

   • @Override: This annotation tells the compiler that this method is intended to override a method from a superclass. If the signature doesn't match a superclass method (e.g., due to a typo), the compiler will flag an error.
   • Specialized Logic: The behavior here is specific to SavingsAccount. It checks its own conditions (balance vs. minimumBalance) to decide on the charge.
   • Accessing balance: Note that balance was protected in Account, so SavingsAccount can access it directly. If it were private, SavingsAccount would need to use getBalance() and a new protected void setBalance(double newBalance) or rely on super.debit() if applicable. For service charges, direct manipulation (if rules are simple) or a dedicated protected adjustBalance() method can be cleaner than using the standard debit which has its own operational rules.

Task 3: Override Service Charge Logic in SalaryAccount

1. Navigate to the SalaryAccount class.

2. Override the applyMonthlyServiceCharge() method.

   • Logic: Service charges are always waived for SalaryAccounts as a benefit.
   • Print an informative message.

   // Inside SalaryAccount class
   @Override
   public void applyMonthlyServiceCharge() {
       // HINT: Overriding allows for completely different behavior.
       // Salary accounts typically have fee waivers.
       System.out.printf("Monthly service charge is WAIVED for Salary Account %s as a premium benefit.%n", getAccountNumber());
       // No change to balance.
   }

3. Explanation:

   • The SalaryAccount completely redefines the behavior. It doesn't apply any charge. This is a common use of overriding – to provide a "do nothing" or "do something entirely different" implementation.

Task 4: Override Service Charge Logic in CurrentAccount

1. Navigate to the CurrentAccount class.

2. Override the applyMonthlyServiceCharge() method.

   • Logic: Apply a fixed monthly service charge of ₹200.00. This charge is applied regardless of the balance (it can even increase the overdraft if the account is already in one, up to a reasonable limit, or just be added).
   • Print an informative message.

   // Inside CurrentAccount class
   @Override
   public void applyMonthlyServiceCharge() {
       double fixedCharge = 200.00;
       System.out.printf("Applying fixed monthly service charge of ₹%.2f to Current Account %s.%n", fixedCharge, getAccountNumber());
       
       // For CurrentAccount, the charge applies. We can directly adjust the balance.
       // The standard debit method has overdraft logic which we might want to use,
       // or we can directly adjust. Let's try direct adjustment for clarity of the charge.
       // This charge might increase overdraft.
       this.balance -= fixedCharge; // Directly accessing 'balance' (protected)
       
       System.out.printf("Fixed service charge applied. New balance for %s: ₹%.2f%n", getAccountNumber(), this.balance);
   }

3. Explanation:

   • The CurrentAccount also provides its unique logic – a fixed charge.
   • Notice that none of these overridden methods (in SavingsAccount, SalaryAccount, CurrentAccount) explicitly call super.applyMonthlyServiceCharge(). This is because their charging logic is entirely self-contained and doesn't need to build upon the base class's (empty/generic) behavior for this particular method. If the base class did something essential that needed to happen first, then a super call would be appropriate.

Task 5: Demonstrate in BankingSystemDemo.java (main method)

1. Navigate to the main method in your BankingSystemDemo class.

2. At the end of each customer's simulation block (Tasks 5.1, 5.2, 5.3), add a call to applyMonthlyServiceCharge() for their respective account.
   For example, for Customer 1 (Priya Sharma - Savings Account):

   // Inside Task 5.1, after other operations for priyaSavings
   System.out.println("\n--- Applying Monthly Service Charge for Ms. Priya ---");
   priyaSavings.applyMonthlyServiceCharge(); // <<< NEW CALL
   System.out.println("\nFinal Details for Ms. Priya (after service charge):");
   System.out.println(priyaSavings.getAccountDetails());

   Do similarly for rohanSalary and innovateBiz.

3. Observe Polymorphism in the "End of Day Branch Summary" (Task 5.4):
   Modify the loop that iterates through allAccounts to also call applyMonthlyServiceCharge(). This is where polymorphism shines!

   // Inside Task 5.4
   System.out.println("\n\n--- Applying End of Month Service Charges & Branch Summary ---");
   double totalBankBalance = 0; // Recalculate after charges
   Account richestAccount = null;
   
   if (allAccounts.isEmpty()) {
       System.out.println("No accounts processed today.");
   } else {
       for (Account acc : allAccounts) { // acc is of type Account (compile-time)
           System.out.println("------------------------------------");
           System.out.println("Processing account: " + acc.getAccountNumber());
           
           // HINT: Polymorphic Call!
           // The JVM determines at runtime which version of applyMonthlyServiceCharge() to call
           // based on the actual object type (SavingsAccount, SalaryAccount, CurrentAccount).
           acc.applyMonthlyServiceCharge();
           
           System.out.println(acc.getAccountDetails()); // Details after charge
           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 (after service charges): ₹%.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());
       }
   }

Task 6: Compile and Run

1. Save your BankingSystemDemo.java file.
2. Compile and run it.
3. Observe the output carefully. You should see:
   • The specific service charge messages and balance changes for Priya's SavingsAccount.
   • The waiver message for Rohan's SalaryAccount.
   • The fixed charge message and balance change for Innovate Solutions Ltd.'s CurrentAccount.
   • Crucially, in the "End of Day" summary loop, observe how acc.applyMonthlyServiceCharge() invokes the correct method for each account type, even though acc is declared as Account.

Explanation of Key Concepts Illustrated:

• Method Overriding: You've provided specialized implementations of applyMonthlyServiceCharge() in each subclass.
• @Override Annotation: This helps prevent subtle bugs by ensuring your overridden method signature correctly matches the superclass method. If you misspelled applyMonthlyServiceCharge or changed its parameters in a subclass without @Override, you'd be creating a new method, not overriding, and the polymorphic calls wouldn't work as expected.
• Polymorphism (Dynamic Method Dispatch):
  When you have code like:

  Account myAccount = new SavingsAccount(...);
  myAccount.applyMonthlyServiceCharge(); // Calls SavingsAccount's version
  
  myAccount = new SalaryAccount(...);
  myAccount.applyMonthlyServiceCharge(); // Calls SalaryAccount's version

  The Java Virtual Machine (JVM) determines at runtime which actual object myAccount refers to (e.g., SavingsAccount, SalaryAccount) and calls that specific object's version of applyMonthlyServiceCharge(). This is dynamic method dispatch. It's powerful because you can write generic code that operates on base class types (Account), and it automatically adapts to the specific behaviors of subclasses.
• Code Maintainability and Extensibility:
  Imagine if you didn't use overriding. You might have one large applyMonthlyServiceCharge() method in the Account class with many if (account instanceof SavingsAccount) { ... } else if (account instanceof SalaryAccount) { ... } checks. This becomes very hard to manage as you add new account types. With overriding, each account type encapsulates its own charging logic. If JPMC introduces a "StudentAccount" later, you just create that class, extend Account, and override applyMonthlyServiceCharge() with its specific rules, without touching the existing, tested code for other account types (Open/Closed Principle).

[Sdey0907]

Task 1 - Sayan Dey

class Account {
private String accountNumber;
protected double balance;

public Account(String accountNumber, double balance) {
    this.accountNumber = accountNumber;
    this.balance = balance;
}

public String getAccountNumber() {
    return accountNumber;
}

public double getBalance() {
    return balance;
}

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

public void withdraw(double amount) {
    balance -= amount;
}
public void applyMonthlyServiceCharge() {
    System.out.printf("No specific monthly service charge defined for generic Account %s.%n", getAccountNumber());
    
}

}

Task 2 - Sayan Dey

public class SavingsAccount extends Account {
protected double minimumBalance;

public SavingsAccount(String accountNumber, double balance, double minimumBalance) {
    super(accountNumber, balance);
    this.minimumBalance = minimumBalance;
}

public boolean debit(double amount) {
    if ((balance - amount) >= minimumBalance) {
        balance -= amount;
        return true;
    }
    System.out.println("Debit failed: Minimum balance constraint.");
    return false;
}

@Override
public void applyMonthlyServiceCharge() {
    System.out.printf("Evaluating monthly service charge for Savings Account %s...%n", getAccountNumber());
    double serviceCharge = 50.00;
    boolean chargeApplicable = (getBalance() < (this.minimumBalance + 500.00)) && (getBalance() >= serviceCharge);

    if (chargeApplicable) {
        System.out.printf("Savings Account %s balance (₹%.2f) is low. Applying service charge of ₹%.2f.%n",
                getAccountNumber(), getBalance(), serviceCharge);

        if (balance >= serviceCharge) {
            balance -= serviceCharge;
            System.out.printf("Service charge applied. New balance for %s: ₹%.2f%n",
                    getAccountNumber(), balance);
        } else {
            System.out.printf("Service charge ₹%.2f cannot be applied. Insufficient funds in %s. Balance: ₹%.2f%n",
                    serviceCharge, getAccountNumber(), balance);
        }
    } else {
        System.out.printf("Service charge waived for Savings Account %s. Balance (₹%.2f) is adequate.%n",
                getAccountNumber(), getBalance());
    }
}

}

Task 3 - Sayan Dey

public class SalaryAccount extends Account {

public SalaryAccount(String accountNumber, double balance) {
    super(accountNumber, balance);
}

@Override
public void applyMonthlyServiceCharge() {
   
    System.out.printf("Monthly service charge is WAIVED for Salary Account %s as a premium benefit.%n", getAccountNumber());
   
}

}

Task 4 - Sayan Dey

public class CurrentAccount extends Account {
private double overdraftLimit;

public CurrentAccount(String accountNumber, double balance, double overdraftLimit) {
    super(accountNumber, balance);
    this.overdraftLimit = overdraftLimit;
}

@Override
public void applyMonthlyServiceCharge() {
    double fixedCharge = 200.00;
    System.out.printf("Applying fixed monthly service charge of ₹%.2f to Current Account %s.%n", fixedCharge, getAccountNumber());

    this.balance -= fixedCharge;

    System.out.printf("Fixed service charge applied. New balance for %s: ₹%.2f%n", getAccountNumber(), this.balance);
}

}