What Is Dynamic Method Dispatch?

Dynamic method dispatch is the rule that a call to an instance method is resolved at run time, based on the actual type of the object the reference points at, rather than on the type the reference was declared as. It is what makes the phrase "program to an interface, not an implementation" actually work.

Mechanically, every object carries a pointer to its class's method table. When you invoke an instance method, the JVM looks up the entry for that method in the runtime class of the receiver — not in the class the compiler saw — and calls it. If the runtime class has an override, that override runs. This is also known as late binding, and it is the mechanism behind polymorphism.

The distinction that causes the most confusion is between the static type and the runtime type. The static type is the type in the declaration, and it decides which methods you are allowed to call and which overload applies. The runtime type is the class of the actual object, and it decides which implementation runs. So if a variable is declared as Animal but holds a Dog, you can only call methods that Animal declares, and the Dog's override of those methods is what runs.

Dispatch applies to instance methods only. A static method is resolved by the compiler from the static type, and a private method cannot be overridden at all, so neither is subject to dispatch.

When they differ, the runtime type decides which implementation executes and the static type decides what you are allowed to call. Both halves of that sentence matter, and the second one is the one that surprises people.

public class Main {
    public static void main(String[] args) {
        // The static type is Animal; the runtime type is Dog.
        Animal a = new Dog();

        // Dispatch: the Dog implementation runs.
        System.out.println("speak : " + a.speak());

        // Not overridden: the inherited Animal implementation runs.
        System.out.println("legs  : " + a.legs());

        // toString is overridden, so the Dog version runs.
        System.out.println("string: " + a);

        // The static type limits what you may call at all:
        // a.fetch();   // compile error - fetch() is not declared on Animal
    }
}

class Animal {
    String speak() {
        return "generic";
    }

    int legs() {
        return 4;
    }
}

class Dog extends Animal {
    @Override
    String speak() {
        return "woof";
    }

    String fetch() {
        return "fetching the ball";
    }

    @Override
    public String toString() {
        return "a Dog";
    }
}

The output shows three different outcomes from the same reference type. speak is overridden, so the Dog implementation runs. legs is not overridden, so the inherited Animal implementation runs. And toString is overridden, so the Dog version runs even though the reference is typed as Animal — which is why the third line prints a Dog and not an identity hash code.

The commented-out line is the key insight: you cannot call fetch through an Animal reference even though the object is a Dog and the method exists at run time. To call it you have to cast the reference, which is exactly why interfaces and well-designed abstractions matter — they let the compiler know which behaviour is available without knowing the concrete type.

One more consequence worth knowing: dispatch is per-call, not per-object. If you pass the same Dog to a method whose parameter type is Animal, and that method calls speak, you still get the Dog implementation. The static type of the parameter does not restrict dispatch.