Chapter 25 — Java Polymorphism

class Parent {
    // This is a VIRTUAL method (default in Java)
    public void display() {
        System.out.println("Parent's display method");
    }

    // This is NOT a virtual method (it's final)
    public final void show() {
        System.out.println("Parent's final show method");
    }
}

class Child extends Parent {
    // This OVERRIDES the virtual method from Parent
    @Override
    public void display() {
        System.out.println("Child's display method");
    }
    
    // This would cause a COMPILE ERROR
    // public void show() { 
    //     System.out.println("Cannot override a final method");
    // }
}

public class VirtualMethodExample {
    public static void main(String[] args) {
        // Parent reference pointing to a Child object
        Parent myObj = new Child(); 
        
        // The JVM calls Child's display() method at runtime
        myObj.display(); // Output: Child's display method
        
        // The JVM calls Parent's final show() method
        myObj.show();    // Output: Parent's final show method
    }
}

// Superclass
class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

// Subclass 1
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

// Subclass 2
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

// Main class to demonstrate dynamic dispatch
public class DynamicDispatchDemo {
    public static void main(String[] args) {
        // A single reference variable of type Animal
        Animal myAnimal;
        
        // 1. Reference points to a Dog object
        myAnimal = new Dog();
        myAnimal.makeSound(); // Calls Dog's makeSound() method
        
        // 2. Reference now points to a Cat object
        myAnimal = new Cat();
        myAnimal.makeSound(); // Calls Cat's makeSound() method
        
        // 3. Using polymorphism in a collection
        Animal[] animals = { new Dog(), new Cat(), new Animal() };
        for (Animal animal : animals) {
            // The correct makeSound() is called for each object at runtime
            animal.makeSound();
        }
    }
}

class Animal { public void eat() { System.out.println("Animal eats"); } }
class Dog extends Animal { public void bark() { System.out.println("Dog barks"); } }

public class CastingExample {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        
        // Upcasting: Safe, implicit
        Animal myAnimal = myDog; 
        myAnimal.eat(); // OK
        // myAnimal.bark(); // COMPILE ERROR: bark() is not in Animal class
        
        // Downcasting: Must be explicit, potentially unsafe
        // We are telling the compiler "trust me, this Animal is actually a Dog"
        Dog anotherDog = (Dog) myAnimal;
        anotherDog.bark(); // OK now
        
        // --- Unsafe Downcasting Example ---
        Animal genericAnimal = new Animal();
        // Dog riskyDog = (Dog) genericAnimal; // This would compile...
        // riskyDog.bark(); // ...but would throw a ClassCastException at runtime
    }
}

class Animal { public void eat() { System.out.println("Animal eats"); } }
class Dog extends Animal { public void bark() { System.out.println("Dog barks"); } }
class Cat extends Animal { public void meow() { System.out.println("Cat meows"); } }

public class InstanceofExample {
    public static void checkAnimalType(Animal animal) {
        animal.eat(); // Always safe to call Animal methods
        
        // Safe downcasting using instanceof
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // Safe to cast
            dog.bark();
        } else if (animal instanceof Cat) {
            Cat cat = (Cat) animal; // Safe to cast
            cat.meow();
        } else {
            System.out.println("Unknown animal type.");
        }
    }

    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        Animal genericAnimal = new Animal();
        
        checkAnimalType(myDog);       // Checks and casts to Dog
        checkAnimalType(myCat);       // Checks and casts to Cat
        checkAnimalType(genericAnimal); // Finds no specific type
    }
}

abstract class Payment {
    protected double amount;

    public Payment(double amount) {
        this.amount = amount;
    }

    // Abstract method to be implemented by subclasses
    public abstract void processPayment();

    // Concrete method available to all subclasses
    public void printReceipt() {
        System.out.printf("Receipt: Payment of $%.2f processed.%n", amount);
    }
}

class CreditCardPayment extends Payment {
    private String cardNumber;

    public CreditCardPayment(double amount, String cardNumber) {
        super(amount);
        this.cardNumber = cardNumber;
    }

    @Override
    public void processPayment() {
        System.out.printf("Processing $%.2f via Credit Card ending in %s%n", amount, cardNumber.substring(cardNumber.length() - 4));
    }
}

class PayPalPayment extends Payment {
    private String email;

    public PayPalPayment(double amount, String email) {
        super(amount);
        this.email = email;
    }

    @Override
    public void processPayment() {
        System.out.printf("Processing $%.2f via PayPal account %s%n", amount, email);
    }
}

public class PaymentProcessor {
    public static void main(String[] args) {
        // List of different payment types
        Payment[] payments = {
            new CreditCardPayment(150.75, "1234-5678-9876-5432"),
            new PayPalPayment(99.99, "customer@example.com"),
            new CreditCardPayment(25.50, "5555-6666-7777-8888")
        };

        // Process each payment polymorphically
        for (Payment payment : payments) {
            payment.processPayment(); // Calls the correct implementation
            payment.printReceipt();   // Calls the method from the superclass

            // Use instanceof for specific post-processing logic
            if (payment instanceof CreditCardPayment) {
                System.out.println("-> Sending SMS receipt for Credit Card payment.");
            } else if (payment instanceof PayPalPayment) {
                System.out.println("-> Sending email receipt for PayPal payment.");
            }
            System.out.println("---");
        }
    }
}