Polymorphism, Dynamic Binding, Overloading, and Overriding: 25-Comp-B11 Advanced Software Design, December 2019, Q24

Question 24: Polymorphism, Dynamic Binding, Overloading, and Overriding (Part V)

Question text not reproduced: the examination questions are © Engineers and Geoscientists BC. Open the official past paper (linked at the top of this page) to read the question, then follow the worked solution below.

Polymorphism is the ability of a single name to refer to objects of more than one type, so code written against a general (base/interface) reference operates uniformly over different concrete types (Question 26's "program to an interface" is what makes this useful in practice).

Dynamic binding (late binding) is the RUNTIME mechanism that resolves a polymorphic call to the actual implementing method based on the object's real runtime type, typically via a per-class dispatch table (vtable) consulted at the moment of the call.

Overriding is a subclass supplying its own implementation of a method already declared in a superclass, with an IDENTICAL signature — this is what dynamic binding dispatches between (and, per Question 12's LSP, must not strengthen the base method's precondition or weaken its postcondition).

Overloading is defining multiple methods that share the same name but differ in parameter signature, resolved entirely at COMPILE time with no runtime dispatch involved — a different mechanism from overriding despite the similar name.

class Bird {
    public void makeSound() { System.out.println("..."); }      // overridden below
}
class Sparrow extends Bird {
    @Override
    public void makeSound() { System.out.println("Chirp"); }    // OVERRIDING
}
class SoundUtil {
    void play(Bird b)   { b.makeSound(); }                       // OVERLOADING:
    void play(String s) { System.out.println(s); }               // same name, different signature
}
Bird b = new Sparrow();   // POLYMORPHISM: a Bird reference holds a Sparrow
b.makeSound();            // DYNAMIC BINDING: resolved to Sparrow.makeSound() at runtime

How they relate. Overriding plus dynamic binding together are the runtime mechanism that implements subtype polymorphism; overloading is a completely different, compile-time kind of polymorphism (ad hoc) that never touches the vtable at all — a method accidentally declared with a matching name but a different signature silently overloads rather than overrides, and never participates in dynamic dispatch.

Question 24 of 28: Polymorphism, Dynamic Binding, Overloading, and Overriding

Question 24: Polymorphism, Dynamic Binding, Overloading, and Overriding (Part V)