Java Polymorphism: Method Overriding and Dynamic Method Dispatch

Polymorphism (originating from Greek meaning "many forms") is the ability of an object or method to take on multiple operational behaviors depending on context. In Java, polymorphism is divided into two fundamental types:

1. Compile-Time Polymorphism (Static Binding): Achieved through Method Overloading and operator behavior. Resolved during compilation by javac.
2. Runtime Polymorphism (Dynamic Binding): Achieved through Method Overriding and Dynamic Method Dispatch. Resolved at runtime by the JVM.

Method Overriding Rules in Java

• The method name and parameter signature must match the parent method identically.
• The return type must be identical or a subtype (Covariant Return Type).
• The access modifier cannot be more restrictive than the parent method (e.g. if parent is protected, child cannot make it private; it can be protected or public).
• final, static, and private methods cannot be overridden.

Dynamic Method Dispatch (Upcasting in Action)

Dynamic Method Dispatch occurs when a superclass reference variable holds a subclass Heap object:

// Base Abstract Class
abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a smooth Circle with radius calculation.");
    }
}

class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a 4-cornered Rectangle.");
    }
}

public class DynamicDispatchDemo {
    public static void main(String[] args) {
        // UPCASTING: Superclass reference holds subclass object
        Shape s1 = new Circle();
        Shape s2 = new Rectangle();

        // JVM determines which draw() to call at RUNTIME based on Heap object:
        s1.draw(); // Output: Drawing a smooth Circle...
        s2.draw(); // Output: Drawing a 4-cornered Rectangle.
    }
}