Java Polymorphism - Complete Tutorial

// Base class
abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    // Abstract method - must be implemented by subclasses
    public abstract void makeSound();
    
    // Concrete method - common to all animals
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// Derived classes
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " says: Woof! Woof!");
    }
    
    // Additional method specific to Dog
    public void wagTail() {
        System.out.println(name + " is wagging its tail.");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " says: Meow!");
    }
    
    // Additional method specific to Cat
    public void climbTree() {
        System.out.println(name + " is climbing a tree.");
    }
}

class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " says: Chirp! Chirp!");
    }
    
    // Additional method specific to Bird
    public void fly() {
        System.out.println(name + " is flying.");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        System.out.println("=== Polymorphism Demonstration ===\n");
        
        // Creating objects of different types
        Animal myDog = new Dog("Buddy");
        Animal myCat = new Cat("Whiskers");
        Animal myBird = new Bird("Tweety");
        
        // Array of Animal references
        Animal[] animals = {myDog, myCat, myBird};
        
        // Polymorphic method calls
        System.out.println("=== Making Sounds (Polymorphic Behavior) ===");
        for (Animal animal : animals) {
            animal.makeSound();  // Each animal makes its specific sound
        }
        
        System.out.println("\n=== Eating (Common Behavior) ===");
        for (Animal animal : animals) {
            animal.eat();  // All animals can eat (inherited method)
        }
        
        System.out.println("\n=== Type Checking and Casting ===");
        for (Animal animal : animals) {
            // Check the actual type
            if (animal instanceof Dog) {
                Dog dog = (Dog) animal;  // Safe casting
                dog.wagTail();  // Call Dog-specific method
            } else if (animal instanceof Cat) {
                Cat cat = (Cat) animal;  // Safe casting
                cat.climbTree();  // Call Cat-specific method
            } else if (animal instanceof Bird) {
                Bird bird = (Bird) animal;  // Safe casting
                bird.fly();  // Call Bird-specific method
            }
        }
        
        System.out.println("\n=== Benefits of Polymorphism ===");
        System.out.println("1. Code reusability: One method works for all Animal types");
        System.out.println("2. Extensibility: Easy to add new Animal types");
        System.out.println("3. Maintainability: Changes in one place affect all types");
        System.out.println("4. Flexibility: Objects can be treated generically");
    }
}

public class PolymorphismTypes {
    
    // === COMPILE-TIME POLYMORPHISM (Method Overloading) ===
    
    // Different versions of add method
    public int add(int a, int b) {
        System.out.println("Adding two integers: " + a + " + " + b);
        return a + b;
    }
    
    public double add(double a, double b) {
        System.out.println("Adding two doubles: " + a + " + " + b);
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        System.out.println("Adding three integers: " + a + " + " + b + " + " + c);
        return a + b + c;
    }
    
    public String add(String a, String b) {
        System.out.println("Concatenating strings: \"" + a + "\" + \"" + b + "\"");
        return a + b;
    }
    
    // Constructor overloading (also compile-time polymorphism)
    public PolymorphismTypes() {
        System.out.println("Default constructor called");
    }
    
    public PolymorphismTypes(String message) {
        System.out.println("Parameterized constructor: " + message);
    }
    
    // === RUNTIME POLYMORPHISM (Method Overriding) ===
    
    static class Vehicle {
        public void start() {
            System.out.println("Vehicle is starting...");
        }
        
        public void stop() {
            System.out.println("Vehicle is stopping...");
        }
    }
    
    static class Car extends Vehicle {
        @Override
        public void start() {
            System.out.println("Car engine is starting with a key...");
        }
        
        @Override
        public void stop() {
            System.out.println("Car is applying brakes to stop...");
        }
    }
    
    static class Bike extends Vehicle {
        @Override
        public void start() {
            System.out.println("Bike engine is starting with a kick...");
        }
        
        // No override for stop() - uses parent's implementation
    }
    
    static class ElectricCar extends Car {
        @Override
        public void start() {
            System.out.println("Electric car is starting silently...");
        }
        
        // New method specific to ElectricCar
        public void chargeBattery() {
            System.out.println("Charging electric car battery...");
        }
    }
    
    public static void main(String[] args) {
        System.out.println("=== COMPILE-TIME POLYMORPHISM Examples ===\n");
        
        PolymorphismTypes pt = new PolymorphismTypes();
        PolymorphismTypes pt2 = new PolymorphismTypes("Hello World");
        
        System.out.println("\nMethod Overloading Examples:");
        System.out.println("Result: " + pt.add(5, 10));
        System.out.println("Result: " + pt.add(5.5, 10.5));
        System.out.println("Result: " + pt.add(1, 2, 3));
        System.out.println("Result: " + pt.add("Hello", " World"));
        
        System.out.println("\n=== RUNTIME POLYMORPHISM Examples ===\n");
        
        // Parent reference to child objects
        Vehicle vehicle1 = new Car();
        Vehicle vehicle2 = new Bike();
        Vehicle vehicle3 = new ElectricCar();
        Vehicle vehicle4 = new Vehicle();
        
        Vehicle[] vehicles = {vehicle1, vehicle2, vehicle3, vehicle4};
        
        System.out.println("Starting all vehicles:");
        for (Vehicle v : vehicles) {
            v.start();  // Dynamic method dispatch - JVM decides which method to call
        }
        
        System.out.println("\nStopping all vehicles:");
        for (Vehicle v : vehicles) {
            v.stop();  // Bike uses Vehicle's stop(), others use their own
        }
        
        System.out.println("\n=== Type Checking and Casting ===");
        for (Vehicle v : vehicles) {
            if (v instanceof ElectricCar) {
                ElectricCar ec = (ElectricCar) v;
                ec.chargeBattery();  // Call ElectricCar-specific method
            }
        }
        
        System.out.println("\n=== Key Differences ===");
        System.out.println("Compile-Time:");
        System.out.println("- Decided by compiler during compilation");
        System.out.println("- Based on method signature (name + parameters)");
        System.out.println("- Faster, less flexible");
        
        System.out.println("\nRuntime:");
        System.out.println("- Decided by JVM during execution");
        System.out.println("- Based on actual object type (not reference type)");
        System.out.println("- Slower, more flexible, enables extensibility");
    }
}

// === INTERFACE EXAMPLE ===
interface PaymentMethod {
    // Constants (implicitly public static final)
    double MAX_AMOUNT = 1000000.0;
    
    // Abstract methods (before Java 8)
    boolean processPayment(double amount);
    String getPaymentDetails();
    
    // Default method (Java 8+)
    default boolean validateAmount(double amount) {
        return amount > 0 && amount <= MAX_AMOUNT;
    }
    
    // Static method (Java 8+)
    static String getPaymentSystem() {
        return "Global Payment System";
    }
    
    // Private method (Java 9+)
    private void logTransaction(String details) {
        System.out.println("Transaction logged: " + details);
    }
}

// === ABSTRACT CLASS EXAMPLE ===
abstract class Shape {
    // Instance variables
    protected String color;
    protected boolean filled;
    
    // Constructor
    public Shape(String color, boolean filled) {
        this.color = color;
        this.filled = filled;
    }
    
    // Abstract methods (must be implemented by subclasses)
    public abstract double calculateArea();
    public abstract double calculatePerimeter();
    
    // Concrete methods
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
    }
    
    public boolean isFilled() {
        return filled;
    }
    
    public void setFilled(boolean filled) {
        this.filled = filled;
    }
    
    // Can have final methods
    public final String getShapeType() {
        return this.getClass().getSimpleName();
    }
}

// === CONCRETE CLASSES IMPLEMENTING INTERFACE ===
class CreditCardPayment implements PaymentMethod {
    private String cardNumber;
    private String cardHolder;
    private String expiryDate;
    
    public CreditCardPayment(String cardNumber, String cardHolder, String expiryDate) {
        this.cardNumber = cardNumber;
        this.cardHolder = cardHolder;
        this.expiryDate = expiryDate;
    }
    
    @Override
    public boolean processPayment(double amount) {
        if (!validateAmount(amount)) {
            System.out.println("Invalid amount: $" + amount);
            return false;
        }
        
        System.out.println("Processing credit card payment of $" + amount);
        System.out.println("Card: " + cardNumber.substring(cardNumber.length() - 4));
        return true;
    }
    
    @Override
    public String getPaymentDetails() {
        return "Credit Card - Holder: " + cardHolder + ", Expires: " + expiryDate;
    }
}

class PayPalPayment implements PaymentMethod {
    private String email;
    
    public PayPalPayment(String email) {
        this.email = email;
    }
    
    @Override
    public boolean processPayment(double amount) {
        if (!validateAmount(amount)) {
            System.out.println("Invalid amount: $" + amount);
            return false;
        }
        
        System.out.println("Processing PayPal payment of $" + amount);
        System.out.println("Email: " + email);
        return true;
    }
    
    @Override
    public String getPaymentDetails() {
        return "PayPal - Email: " + email;
    }
}

// === CONCRETE CLASSES EXTENDING ABSTRACT CLASS ===
class Circle extends Shape {
    private double radius;
    
    public Circle(String color, boolean filled, double radius) {
        super(color, filled);
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
    
    public double getRadius() {
        return radius;
    }
    
    public void setRadius(double radius) {
        this.radius = radius;
    }
    
    @Override
    public String toString() {
        return "Circle [radius=" + radius + ", color=" + color + ", filled=" + filled + "]";
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;
    
    public Rectangle(String color, boolean filled, double width, double height) {
        super(color, filled);
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * (width + height);
    }
    
    public double getWidth() {
        return width;
    }
    
    public void setWidth(double width) {
        this.width = width;
    }
    
    public double getHeight() {
        return height;
    }
    
    public void setHeight(double height) {
        this.height = height;
    }
    
    @Override
    public String toString() {
        return "Rectangle [width=" + width + ", height=" + height + 
               ", color=" + color + ", filled=" + filled + "]";
    }
}

// === CLASS USING BOTH ABSTRACT CLASS AND INTERFACE ===
abstract class BankAccount implements PaymentMethod {
    protected String accountNumber;
    protected double balance;
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    // Abstract method specific to BankAccount
    public abstract double calculateInterest();
    
    // Common implementation for PaymentMethod
    @Override
    public boolean processPayment(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println("Bank transfer of $" + amount + " processed");
            return true;
        }
        return false;
    }
}

public class AbstractVsInterface {
    public static void main(String[] args) {
        System.out.println("=== Abstract Classes vs Interfaces ===\n");
        
        System.out.println("=== Payment Methods (Interface Example) ===");
        PaymentMethod[] payments = {
            new CreditCardPayment("1234-5678-9012-3456", "John Doe", "12/25"),
            new PayPalPayment("john.doe@email.com")
        };
        
        for (PaymentMethod payment : payments) {
            System.out.println("\n" + payment.getPaymentDetails());
            System.out.println("Payment System: " + PaymentMethod.getPaymentSystem());
            payment.processPayment(150.75);
        }
        
        System.out.println("\n=== Shapes (Abstract Class Example) ===");
        Shape[] shapes = {
            new Circle("Red", true, 5.0),
            new Rectangle("Blue", false, 4.0, 6.0)
        };
        
        for (Shape shape : shapes) {
            System.out.println("\n" + shape);
            System.out.println("Type: " + shape.getShapeType());
            System.out.println("Area: " + shape.calculateArea());
            System.out.println("Perimeter: " + shape.calculatePerimeter());
        }
        
        System.out.println("\n=== Key Differences ===");
        System.out.println("Abstract Classes:");
        System.out.println("- Can have constructors");
        System.out.println("- Can have instance variables");
        System.out.println("- Can have private/protected methods");
        System.out.println("- Single inheritance");
        System.out.println("- Use 'extends' keyword");
        
        System.out.println("\nInterfaces:");
        System.out.println("- Cannot have constructors");
        System.out.println("- Only constants (no instance variables)");
        System.out.println("- Methods are implicitly public");
        System.out.println("- Multiple inheritance");
        System.out.println("- Use 'implements' keyword");
        
        System.out.println("\n=== When to Use What? ===");
        System.out.println("Use Abstract Class when:");
        System.out.println("- Sharing code among closely related classes");
        System.out.println("- Expecting classes to have common state/behavior");
        System.out.println("- Need to declare non-public methods");
        System.out.println("- Plan to add methods in future (can be concrete)");
        
        System.out.println("\nUse Interface when:");
        System.out.println("- Unrelated classes need to share capability");
        System.out.println("- Multiple inheritance is needed");
        System.out.println("- Defining a contract/API");
        System.out.println("- Future expansion with default methods");
        
        System.out.println("\n=== Java 8+ Enhancements ===");
        System.out.println("1. Default methods: Add methods without breaking implementations");
        System.out.println("2. Static methods: Utility methods in interfaces");
        System.out.println("3. Functional interfaces: Single abstract method (for lambdas)");
        System.out.println("4. Private methods: Helper methods in interfaces (Java 9+)");
    }
}

public class PolymorphismChecklist {
    
    public static void polymorphismChecklist() {
        System.out.println("=== Polymorphism Implementation Checklist ===\n");
        
        System.out.println("1. ✅ Understand the Problem");
        System.out.println("   - Is polymorphism the right solution?");
        System.out.println("   - Identify common behaviors/attributes");
        System.out.println("   - Plan inheritance hierarchy or interfaces");
        
        System.out.println("\n2. ✅ Design the Interface/Abstract Class");
        System.out.println("   - Define common method signatures");
        System.out.println("   - Consider access modifiers");
        System.out.println("   - Plan for future extensions");
        
        System.out.println("\n3. ✅ Implement Method Overriding");
        System.out.println("   - Use @Override annotation");
        System.out.println("   - Maintain method contracts");
        System.out.println("   - Call super.method() when appropriate");
        
        System.out.println("\n4. ✅ Implement Method Overloading");
        System.out.println("   - Ensure method signatures differ");
        System.out.println("   - Keep overloaded methods semantically similar");
        System.out.println("   - Consider using varargs for flexibility");
        
        System.out.println("\n5. ✅ Test Polymorphic Behavior");
        System.out.println("   - Test with different concrete types");
        System.out.println("   - Verify Liskov Substitution Principle");
        System.out.println("   - Test edge cases and null values");
        
        System.out.println("\n6. ✅ Consider Performance");
        System.out.println("   - Virtual method call overhead is minimal");
        System.out.println("   - Use final for methods that won't be overridden");
        System.out.println("   - Profile before optimizing");
        
        System.out.println("\n7. ✅ Document the Design");
        System.out.println("   - Document intended polymorphic behavior");
        System.out.println("   - Note any assumptions or constraints");
        System.out.println("   - Provide examples of usage");
    }
    
    // Example: Well-designed polymorphic hierarchy
    interface Notification {
        void send(String message);
        String getType();
    }
    
    static class EmailNotification implements Notification {
        private String emailAddress;
        
        public EmailNotification(String emailAddress) {
            this.emailAddress = emailAddress;
        }
        
        @Override
        public void send(String message) {
            System.out.println("Sending email to " + emailAddress + ": " + message);
        }
        
        @Override
        public String getType() {
            return "Email";
        }
    }
    
    static class SMSNotification implements Notification {
        private String phoneNumber;
        
        public SMSNotification(String phoneNumber) {
            this.phoneNumber = phoneNumber;
        }
        
        @Override
        public void send(String message) {
            System.out.println("Sending SMS to " + phoneNumber + ": " + message);
        }
        
        @Override
        public String getType() {
            return "SMS";
        }
    }
    
    static class PushNotification implements Notification {
        private String deviceId;
        
        public PushNotification(String deviceId) {
            this.deviceId = deviceId;
        }
        
        @Override
        public void send(String message) {
            System.out.println("Sending push notification to device " + deviceId + ": " + message);
        }
        
        @Override
        public String getType() {
            return "Push";
        }
    }
    
    static class NotificationService {
        private List notifications = new ArrayList<>();
        
        public void addNotification(Notification notification) {
            notifications.add(notification);
        }
        
        public void broadcast(String message) {
            System.out.println("Broadcasting message: " + message);
            for (Notification notification : notifications) {
                notification.send(message);
            }
        }
        
        public void sendToType(String message, String type) {
            for (Notification notification : notifications) {
                if (notification.getType().equals(type)) {
                    notification.send(message);
                }
            }
        }
    }
    
    public static void main(String[] args) {
        polymorphismChecklist();
        
        System.out.println("\n=== Example: Notification System ===");
        
        NotificationService service = new NotificationService();
        service.addNotification(new EmailNotification("user@example.com"));
        service.addNotification(new SMSNotification("+1234567890"));
        service.addNotification(new PushNotification("device-123"));
        
        System.out.println("\n=== Broadcast to All ===");
        service.broadcast("System maintenance scheduled for tonight.");
        
        System.out.println("\n=== Send to Specific Type ===");
        service.sendToType("Your order has shipped!", "SMS");
        
        System.out.println("\n=== Benefits of This Design ===");
        System.out.println("1. Easy to add new notification types");
        System.out.println("2. Single service handles all notification types");
        System.out.println("3. Type-specific behavior encapsulated");
        System.out.println("4. Easy to test each notification type");
        System.out.println("5. Flexible routing (broadcast or type-specific)");
        
        System.out.println("\n=== Final Recommendations ===");
        System.out.println("For new projects:");
        System.out.println("- Start with interfaces for maximum flexibility");
        System.out.println("- Use abstract classes only when sharing code");
        System.out.println("- Design small, focused interfaces (Interface Segregation)");
        
        System.out.println("\nFor existing code:");
        System.out.println("- Refactor to use polymorphism where appropriate");
        System.out.println("- Replace conditional logic with polymorphism");
        System.out.println("- Consider strategy pattern for varying algorithms");
    }
}