Polymorphism and Dynamic Dispatch

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Polymorphism

Greek for 'many forms'. In Java: one type (like Shape) can refer to objects of many classes, and each responds to calls in its own way.

Declared type

The type written for a variable or expression in the source code. The compiler checks calls against it. Also called the static or compile-time type.

Runtime class

The actual class of the object in memory, the one used with new. getClass() returns it.

Dynamic dispatch

Choosing which method body to run at run time, based on the object's runtime class. Also called late binding.

vtable

Virtual method table: a per-class array of pointers to the method code for each overridable method, used to find the right override quickly.

invokevirtual

The bytecode instruction for a normal instance-method call on a class type. It triggers dynamic dispatch.

Inlining

A JIT optimisation that copies a small method's body into the caller, removing the call entirely.

Open/closed principle

Code should be open to new behaviour (add a subclass) without modifying existing code (the loop that uses it).

1. 1

   Add a new shape without touching the loop

   In the shapes example, add class Triangle extends Shape with base and height, overriding area() (0.5 × b × h) and name(). Add new Triangle(4, 3) to the array only. Predict the new total (19.14) and run.

2. 2

   Watch the compiler refuse

   In the shapes example, inside the loop write System.out.println(s.r);. Read the cannot find symbol error: the compiler only knows s is a Shape. Then guard it with if (s instanceof Circle c) System.out.println(c.r); (Topic 5.5).

3. 3

   Look at the bytecode yourself

   If you have a JDK installed locally, compile the shapes example and run javap -c Main. Find the invokevirtual lines for name() and area(); both name Shape, never Circle.

   terminalcopy cmd

   $ javac Main.java

   javap -c Main | findstr invokevirtual

   ── expected output ──

   ...invokevirtual #NN // Method Shape.name:()Ljava/lang/String;

   ...invokevirtual #NN // Method Shape.area:()D

   ...

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

class Animal { void speak() { } }
class Dog extends Animal { void fetch() { } }
public class Main { public static void main(String[] a) { Animal a1 = new Dog(); a1.fetch(); } }

1. 1

   A variable has a declared type (also called static or compile-time type), written in the source: Shape s. The object it points to has a runtime class: new Circle(1). Because a Circle *is a* Shape, the assignment is allowed. This is the heart of subtype polymorphism.

2. 2

   The compiler uses the declared type to decide what you're *allowed* to call. If Shape has no radius() method, s.radius() fails to compile even when s holds a Circle. The JVM uses the runtime class to decide *which code runs*. s.area() runs Circle's area(). Compile-time checks, run-time choice.

3. 3

   This run-time choice is dynamic dispatch (or late binding). The bytecode for s.area() is invokevirtual Shape.area(); at run time the JVM looks in the object's class for the most specific area(). Calls through an interface type use invokeinterface, which works the same way.

4. 4

   Only instance methods are dispatched dynamically. Fields are chosen by the declared type, static methods by the declared type, private methods and constructors are called directly, and overloads are chosen by argument types at compile time (Topic 5.3).

5. 5

   Why it matters: code written against the parent type works with every subclass, including ones written later. A loop over List<Shape> that calls area() never changes when you add Triangle. This is the open/closed principle: open for extension, closed for modification.

6. 6

   Under the hood, HotSpot gives each class a vtable, an array of method pointers. A subclass copies its parent's table and replaces the entries it overrides, so area() sits at the same slot index in every Shape subclass. A virtual call is then: load the object's class, load slot N, jump. The JIT usually does even better by inlining the likely target.

• ↔

  Polymorphism moves the 'which kind is it?' decision out of if/switch chains into the class hierarchy. Adding a new kind is easy (a new subclass); adding a new *operation* to every kind means touching every class. Pattern matching over sealed types (Topic 5.11) flips that trade-off.

• ↔

  Programming to the parent type makes code flexible, but readers must look in several classes to know what a call does. Keep hierarchies shallow and override sparingly.

• ↔

  In very hot code, megamorphic call sites cost real time. Usually irrelevant; measure before restructuring.

• Done when you can explain declared type vs runtime class and what each controls.

• Done when you can predict output involving fields, static methods and overridden methods through a parent reference.

• Done when you can name the four invoke instructions and which ones dispatch.

• Done when you can explain vtables and inline caches at an interview level.

• Done when you can write a loop over a parent type that works for any future subclass.