Compile-Time vs Runtime Polymorphism in Java

Polymorphism in Java means the same method call can produce different behavior depending on the object it's called on. Java achieves this two ways: overloading at compile time, and overriding at runtime. Most of what interviewers call "polymorphism" refers to the runtime kind — the mechanism that makes interface-based design actually work.

Compile-time polymorphism — overloading:

• Overloading lets you define multiple methods with the same name but different parameter types — the compiler resolves which version to call based on the declared argument types at the call site
• The key point is that the reference type decides, not the actual object: passing Animal a = new Dog() to an overloaded method runs the Animal version, because the compiler locked in its choice before the program ran
• Overloading is a naming convenience — it keeps your API clean by letting you write draw(Circle) and draw(Rectangle) instead of two different method names; it doesn't provide architectural flexibility

Runtime polymorphism — overriding:

• When you call an overridden method, the JVM uses a per-class virtual method table (vtable) to dispatch to the actual object's implementation — not the reference type's version
• Animal a = new Dog(); a.speak() calls Dog.speak() — the JVM checks Dog's vtable at execution time, even though the reference is declared as Animal
• This is what makes List work: you iterate and call shape.draw() on each element, and the JVM routes to Circle.draw(), Rectangle.draw(), or whatever the real object is — no instanceof checks needed

The static method trap:

• Static methods are hidden, not overridden — they bypass the vtable entirely, so the declared reference type decides which version runs, not the actual object
• This is the standard interview trick: both parent and child define static void display() — calling it via an Animal reference always runs Animal.display() even when the object is a Dog; the object type is irrelevant

I recommend writing @Override on every intended override — without it, a mistyped method signature silently creates a new method or hides a static method instead of overriding, and the compiler gives no warning.