Java Polymorphism: Overloading, Overriding, and Dynamic Dispatch

🔍 What Is It?

Java has two types of polymorphism:

1. Runtime Polymorphism (Dynamic Dispatch)

Method overriding — the most specific implementation is called based on the actual runtime type. This is what most people mean by polymorphism.

2. Compile-time Polymorphism (Method Overloading)

Multiple methods with the same name but different parameter lists. The compiler selects the correct one based on the argument types.

Key Mechanism:

The language defines observable dispatch behavior, not one mandatory lookup structure. A JVM may use method tables, inline caches, or optimized direct calls while preserving the specified method selection rules.

Overloading versus overriding

Covariant Return Types:

A subclass can override a method and return a more specific type than the parent declared.

Dispatch limits

• →Static methods are hidden, not overridden; use the declaring class name to call them clearly.
• →Fields are selected by the reference's compile-time type, not dynamically dispatched.
• →Private methods are not inherited as override targets; final methods cannot be overridden.
• →Constructors are not overridden.
• →Runtime overriding can be observed through either a parent/interface reference or a concrete reference; a parent-typed variable is a useful demonstration, not a requirement.

🎯 Why Do We Need It?

Polymorphism is the foundation of extensible software:

• →Open/Closed Principle — code is open for extension (add new types) but closed for modification (don't change existing code)
• →Dependency Inversion — depend on abstractions (interfaces), not concrete classes
• →Strategy Pattern — swap algorithms at runtime by swapping implementations
• →Framework design — a Spring client can depend on an interface while a configured implementation supplies the behavior

Without polymorphism, adding a new payment type requires modifying every place that processes payments. With polymorphism, you add a new class and the existing code works automatically.

🏗️ What Happens in Real Projects?

Every Spring Boot application uses polymorphism constantly:

• →@Service classes implement service interfaces — controllers depend on the interface
• →@Repository extends JpaRepository — Spring generates the implementation at runtime
• →Exception handlers use polymorphism — catch(Exception e) catches all subtypes
• →Notification systems — EmailNotifier, SMSNotifier, PushNotifier all implement Notifier

⚙️ How It Works

Method invocation has two important stages:

1. At compile time, Java checks the reference type, accessible declarations, argument types, and overload rules to select a method signature.
2. At runtime, an ordinary overridden instance method is dispatched using the receiver object's actual class. Static calls do not use this dispatch rule.

If Person person = new Student(), then person.speak() can execute Student's override. But an overloaded describe(person) is selected using the declared Person argument type; Java does not switch to a Student overload merely because the argument holds a Student object.

For overloads accepting int, Integer, and long, process(null) selects the reference-type Integer overload. Null cannot be passed directly to a primitive parameter. With unrelated reference overloads such as String and Integer, select(null) is ambiguous unless an explicit type disambiguates it.

💻 Example

Polymorphism in a Notification System — How polymorphism makes adding new notification channels trivial.

public class PolymorphismDemo {
    static class Person {
        public String speak() { return "Person speaking"; }
    }

    static class Student extends Person {
        @Override
        public String speak() { return "Student speaking"; }
    }

    static String describe(Person value) { return "Person overload"; }
    static String describe(Student value) { return "Student overload"; }

    static String process(int value) { return "int overload"; }
    static String process(Integer value) { return "Integer overload"; }
    static String process(long value) { return "long overload"; }

    public static void main(String[] args) {
        Person person = new Student();
        System.out.println(person.speak());           // Student speaking
        System.out.println(describe(person));         // Person overload
        System.out.println(describe((Student) person)); // Student overload
        System.out.println(process(null));           // Integer overload
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits