Method Overriding in Java Explained — How, Why, and When to Use It

// PaymentProcessorDemo.java
// Real-world scenario: a payment system that supports multiple payment methods.
// The calling code (checkout) never changes when we add a new payment type.

class PaymentProcessor {

    // Parent method — defines the contract.
    // Every payment processor CAN process a payment, but HOW is up to the subclass.
    public String processPayment(double amount) {
        return "Processing $" + amount + " via generic payment processor.";
    }

    public String getProcessorName() {
        return "Generic Processor";
    }
}

class CreditCardProcessor extends PaymentProcessor {

    // @Override tells the compiler: "I'm intentionally replacing the parent method."
    // If we typo the method name, the compiler catches it immediately.
    @Override
    public String processPayment(double amount) {
        // Subclass provides its own implementation — completely different logic.
        return "Charging $" + amount + " to credit card via Stripe gateway.";
    }

    @Override
    public String getProcessorName() {
        return "Credit Card Processor";
    }
}

class PayPalProcessor extends PaymentProcessor {

    @Override
    public String processPayment(double amount) {
        return "Sending $" + amount + " via PayPal. Redirecting to paypal.com...";
    }

    @Override
    public String getProcessorName() {
        return "PayPal Processor";
    }
}

class CryptoProcessor extends PaymentProcessor {

    private String walletAddress;

    public CryptoProcessor(String walletAddress) {
        this.walletAddress = walletAddress;
    }

    @Override
    public String processPayment(double amount) {
        // Subclass can use its own fields while still honouring the parent's contract.
        return "Transferring $" + amount + " in BTC to wallet: " + walletAddress;
    }

    @Override
    public String getProcessorName() {
        return "Crypto Processor";
    }
}

public class PaymentProcessorDemo {

    // This method accepts ANY PaymentProcessor — it doesn't know or care which one.
    // This is the power of overriding: the calling code is completely decoupled.
    public static void checkout(PaymentProcessor processor, double orderTotal) {
        System.out.println("--- Checkout using: " + processor.getProcessorName() + " ---");
        // Java resolves the correct processPayment() at RUNTIME based on actual object type.
        String result = processor.processPayment(orderTotal);
        System.out.println(result);
        System.out.println();
    }

    public static void main(String[] args) {
        double orderTotal = 149.99;

        // Same checkout() call — different behaviour each time. That's runtime polymorphism.
        checkout(new CreditCardProcessor(), orderTotal);
        checkout(new PayPalProcessor(), orderTotal);
        checkout(new CryptoProcessor("1A2B3C4D5E6F"), orderTotal);

        // Even using a parent-type reference, Java dispatches to the subclass method.
        PaymentProcessor unknownProcessor = new PayPalProcessor();
        System.out.println("Reference type: PaymentProcessor");
        System.out.println("Actual object: PayPalProcessor");
        System.out.println(unknownProcessor.processPayment(50.00));
    }
}

// OverridingRulesDemo.java
// Demonstrates the five overriding rules with concrete, runnable examples.

import java.io.IOException;

class Animal {

    // Rule 1: Subclass must match this exact signature.
    public String describe() {
        return "I am a generic animal.";
    }

    // Rule 2: Returns Animal — subclass may return Animal or any subtype (e.g., Dog).
    public Animal reproduce() {
        return new Animal();
    }

    // Rule 3: protected — subclass may use protected or public, NOT private.
    protected String getHabitat() {
        return "Unknown habitat";
    }

    // Rule 4: Declares IOException — subclass cannot throw a broader checked exception.
    public void loadFromFile() throws IOException {
        System.out.println("Animal loading from file.");
    }

    // Rule 5: static methods belong to the class — NOT polymorphically overridable.
    public static String kingdom() {
        return "Animalia (from Animal class)";
    }
}

class Dog extends Animal {

    // Rule 1 ✅ — identical signature.
    @Override
    public String describe() {
        return "I am a dog. I bark.";
    }

    // Rule 2 ✅ — covariant return: Dog is a subtype of Animal. Perfectly valid.
    @Override
    public Dog reproduce() {
        return new Dog(); // More specific return type — still satisfies the contract.
    }

    // Rule 3 ✅ — widening access from protected to public is allowed.
    @Override
    public String getHabitat() {
        return "Domestic home";
    }

    // Rule 4 ✅ — throwing NO exception is narrower than IOException. Totally fine.
    @Override
    public void loadFromFile() {
        System.out.println("Dog loading from file — no exception declared.");
    }

    // Rule 5 — this is METHOD HIDING, not overriding.
    // The reference type determines which static method is called, not the object type.
    public static String kingdom() {
        return "Animalia (from Dog class)";
    }
}

public class OverridingRulesDemo {

    public static void main(String[] args) throws IOException {

        // --- Rule 1 & 2 & 3 in action ---
        Animal myAnimal = new Dog(); // Parent reference, Dog object.

        // Runtime dispatch picks Dog's describe() — overriding is working.
        System.out.println(myAnimal.describe());

        // Runtime dispatch picks Dog's getHabitat() — access widening worked.
        System.out.println(myAnimal.getHabitat());

        // Covariant return: calling through Animal reference returns Animal.
        // Actual object returned is a Dog — checked with instanceof.
        Animal offspring = myAnimal.reproduce();
        System.out.println("Offspring is Dog? " + (offspring instanceof Dog));

        // --- Rule 4 in action ---
        myAnimal.loadFromFile(); // Calls Dog's version — no exception thrown.

        // --- Rule 5: Static method hiding — NOT polymorphism ---
        Animal animalRef = new Dog();
        Dog dogRef = new Dog();

        // Static calls resolved at COMPILE TIME using the reference type — not the object.
        System.out.println(animalRef.kingdom()); // Uses Animal's kingdom()
        System.out.println(dogRef.kingdom());    // Uses Dog's kingdom()
        System.out.println(Animal.kingdom());    // Preferred way to call static methods.
    }
}

// TransactionAuditDemo.java
// Real-world scenario: a bank transaction system where the base class handles
// the core transfer, and subclasses add their own specialised behaviour on top.

class BankTransaction {

    protected String accountId;
    protected double balance;

    public BankTransaction(String accountId, double initialBalance) {
        this.accountId = accountId;
        this.balance = initialBalance;
    }

    // Core transaction logic that ALL subclasses benefit from.
    public void processTransaction(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Transaction amount must be positive.");
        }
        balance -= amount;
        // Every subclass gets this audit trail for free via super.
        System.out.println("[BASE AUDIT] Account " + accountId +
                " | Debited: $" + amount +
                " | New Balance: $" + balance);
    }
}

class InternationalTransaction extends BankTransaction {

    private static final double FX_FEE_PERCENT = 0.025; // 2.5% foreign exchange fee

    public InternationalTransaction(String accountId, double initialBalance) {
        super(accountId, initialBalance);
    }

    @Override
    public void processTransaction(double amount) {
        double fxFee = amount * FX_FEE_PERCENT;
        double totalCharge = amount + fxFee;

        System.out.println("[INTERNATIONAL] Applying FX fee of $" +
                String.format("%.2f", fxFee) + " on transfer of $" + amount);

        // Call the parent's logic to handle the actual debit and audit trail.
        // We don't duplicate that logic — we reuse it.
        super.processTransaction(totalCharge);

        System.out.println("[INTERNATIONAL] Transfer complete. Total charged: $" +
                String.format("%.2f", totalCharge));
    }
}

class FraudCheckedTransaction extends BankTransaction {

    private static final double FRAUD_THRESHOLD = 10_000.00;

    public FraudCheckedTransaction(String accountId, double initialBalance) {
        super(accountId, initialBalance);
    }

    @Override
    public void processTransaction(double amount) {
        // Pre-processing step: run fraud check BEFORE calling the parent.
        if (amount > FRAUD_THRESHOLD) {
            System.out.println("[FRAUD ALERT] Transaction of $" + amount +
                    " exceeds threshold. Flagging for manual review.");
            // We deliberately do NOT call super here — fraud check blocks the transaction.
            return;
        }

        System.out.println("[FRAUD CHECK] Amount $" + amount + " passed screening.");
        // Safe to proceed — delegate to parent for the actual debit.
        super.processTransaction(amount);
    }
}

public class TransactionAuditDemo {

    public static void main(String[] args) {

        System.out.println("=== International Transaction ===");
        InternationalTransaction intlTx =
                new InternationalTransaction("ACC-001", 5000.00);
        intlTx.processTransaction(1000.00);

        System.out.println();

        System.out.println("=== Fraud-Checked Transaction (safe amount) ===");
        FraudCheckedTransaction fraudTx =
                new FraudCheckedTransaction("ACC-002", 20000.00);
        fraudTx.processTransaction(500.00);

        System.out.println();

        System.out.println("=== Fraud-Checked Transaction (suspicious amount) ===");
        fraudTx.processTransaction(15000.00);
    }
}

// OverrideVsOverloadDemo.java
// Side-by-side demo: overloading in the same class, overriding across class hierarchy.

class NotificationService {

    // --- OVERLOADING: same class, same method name, different parameter lists ---
    // The compiler picks the right one based on what arguments you pass.

    public void sendAlert(String message) {
        // Overload 1: just a plain message string.
        System.out.println("[EMAIL] Sending alert: " + message);
    }

    public void sendAlert(String message, String recipientEmail) {
        // Overload 2: message + a specific email address.
        System.out.println("[EMAIL] Sending '" + message + "' to " + recipientEmail);
    }

    public void sendAlert(String message, int priorityLevel) {
        // Overload 3: message + numeric priority. Same name, different signature.
        System.out.println("[EMAIL] Priority " + priorityLevel + " alert: " + message);
    }

    // --- Method to be OVERRIDDEN by subclasses ---
    public String getChannel() {
        return "Email";
    }
}

class SmsNotificationService extends NotificationService {

    // --- OVERRIDING: subclass redefines parent's method. Resolved at runtime. ---
    @Override
    public String getChannel() {
        return "SMS"; // Completely replaces the parent's "Email" response.
    }

    // Subclass can ALSO overload — adds a new overload specific to SMS.
    public void sendAlert(String message, String phoneNumber, boolean isUrgent) {
        String urgencyTag = isUrgent ? "[URGENT] " : "";
        System.out.println("[SMS] Sending '" + urgencyTag + message +
                "' to " + phoneNumber);
    }
}

public class OverrideVsOverloadDemo {

    public static void main(String[] args) {

        System.out.println("--- Overloading: resolved at compile time ---");
        NotificationService emailService = new NotificationService();

        // Compiler picks the correct overload based on argument types.
        emailService.sendAlert("Server is down");                        // Overload 1
        emailService.sendAlert("Server is down", "admin@company.com");  // Overload 2
        emailService.sendAlert("Server is down", 1);                    // Overload 3

        System.out.println();
        System.out.println("--- Overriding: resolved at runtime ---");

        // Parent reference, but the actual object is SmsNotificationService.
        NotificationService service = new SmsNotificationService();

        // At runtime, JVM sees the real object is SmsNotificationService
        // and calls ITS getChannel() — not NotificationService's.
        System.out.println("Notification channel: " + service.getChannel());

        System.out.println();
        System.out.println("--- SMS-specific overload (only on SmsNotificationService) ---");
        SmsNotificationService smsService = new SmsNotificationService();
        smsService.sendAlert("Payment confirmed", "+1-555-0199", false);
        smsService.sendAlert("Fraud detected", "+1-555-0199", true);
    }
}