Polymorphism in Java – Compile-Time and Runtime Polymorphism

public class CompileTimePolymorphism {
    // Same name, different parameter lists: the compiler picks the method
    static int area(int side)                 { return side * side; }
    static int area(int length, int width)    { return length * width; }
    static double area(double radius)         { return Math.PI * radius * radius; }

    public static void main(String[] args) {
        System.out.println("Square:    " + area(5));
        System.out.println("Rectangle: " + area(4, 6));
        System.out.printf("Circle:    %.2f%n", area(2.0));
        // println itself is overloaded: println(int), println(String), println(Object), ...
    }
}

import java.util.List;

public class RuntimePolymorphism {
    static class Payment {
        double fee(double amount) { return 0; }
        String type() { return "Generic"; }
    }
    static class CardPayment extends Payment {
        @Override double fee(double amount) { return amount * 0.02; }
        @Override String type() { return "Card"; }
    }
    static class UpiPayment extends Payment {
        @Override double fee(double amount) { return 0; }
        @Override String type() { return "UPI"; }
    }
    static class WalletPayment extends Payment {
        @Override double fee(double amount) { return Math.min(10, amount * 0.01); }
        @Override String type() { return "Wallet"; }
    }

    public static void main(String[] args) {
        // Reference type: Payment. Object type: decided at run time.
        List<Payment> payments = List.of(new CardPayment(), new UpiPayment(), new WalletPayment());
        for (Payment p : payments) {
            System.out.printf("%-6s fee on 2000 = %.2f%n", p.type(), p.fee(2000));
        }
    }
}

public class UpcastingDowncasting {
    static class Animal {
        void sound() { System.out.println("Some sound"); }
    }
    static class Dog extends Animal {
        @Override void sound() { System.out.println("Woof"); }
        void fetch() { System.out.println("Dog fetches the ball"); }
    }
    static class Cat extends Animal {
        @Override void sound() { System.out.println("Meow"); }
    }

    public static void main(String[] args) {
        Animal a = new Dog();          // upcasting: automatic and always safe
        a.sound();                     // Woof  (object type decides)
        // a.fetch();                  // compile error: Animal has no fetch()

        if (a instanceof Dog d) {      // safe downcast with pattern matching (Java 16+)
            d.fetch();
        }

        Animal c = new Cat();
        try {
            Dog wrong = (Dog) c;       // compiles, but fails at run time
        } catch (ClassCastException e) {
            System.out.println("ClassCastException: a Cat is not a Dog");
        }
    }
}

public class FieldsNotPolymorphic {
    static class Parent {
        String name = "Parent field";
        static String id() { return "Parent static"; }
        String describe() { return "Parent method"; }
    }
    static class Child extends Parent {
        String name = "Child field";                   // hides, does not override
        static String id() { return "Child static"; }  // hides, does not override
        @Override String describe() { return "Child method"; }
    }

    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.describe());   // instance method: overridden -> Child
        System.out.println(p.name);         // field: chosen by reference type -> Parent
        System.out.println(Parent.id());    // static: chosen at compile time
    }
}

public class SealedPolymorphism {
    sealed interface Shape permits Circle, Square, Rect { }
    record Circle(double r) implements Shape { }
    record Square(double side) implements Shape { }
    record Rect(double w, double h) implements Shape { }

    // Pattern matching switch: exhaustive because Shape is sealed (Java 21)
    static double area(Shape s) {
        return switch (s) {
            case Circle c -> Math.PI * c.r() * c.r();
            case Square q -> q.side() * q.side();
            case Rect r   -> r.w() * r.h();
        };
    }

    public static void main(String[] args) {
        Shape[] shapes = { new Circle(1), new Square(3), new Rect(2, 5) };
        for (Shape s : shapes) System.out.printf("%-25s area = %.2f%n", s, area(s));
    }
}