Polymorphism: dynamic dispatch and toString()

Polymorphism: one type, many behaviours

• Polymorphism means "many forms": one superclass type, many subclass behaviours.
• You can hold a Dog or a Cat in an Animal variable, because each is-an Animal.
• When you call a method, the object's real type decides which version runs.

Dynamic dispatch

• The variable's type (Animal) decides which methods you are allowed to call.
• But at run time, the actual object (Dog) decides which overridden version runs.
• This run-time choice is called dynamic dispatch — it is the heart of polymorphism.

public class Main {
    public static void main(String[] args) {
        Animal[] zoo = { new Dog(), new Cat(), new Dog() };
        for (Animal a : zoo) {
            System.out.println(a.speak());   // Woof, then Meow, then Woof
        }
    }
}

class Animal {
    public String speak() { return "some sound"; }
}
class Dog extends Animal {
    public String speak() { return "Woof"; }
}
class Cat extends Animal {
    public String speak() { return "Meow"; }
}

One loop handles every subclass

• The loop above never asks "is this a Dog or a Cat?" — it just calls speak().
• Each object answers in its own way. That keeps the loop short and general.
• Add a brand-new subclass later and the same loop works on it, unchanged.

toString(): every object inherits it from Object

• Every class in Java secretly extends a class called Object, which has a toString().
• Override toString() to say how your object should look as text.
• Java calls it automatically when you print an object or join it with +.

public class Main {
    public static void main(String[] args) {
        Object x = new Fraction(3, 4);
        System.out.println(x);              // 3/4   -- toString() runs
        System.out.println("ratio " + x);   // ratio 3/4
    }
}

class Fraction {
    private int numerator;
    private int denominator;
    public Fraction(int numerator, int denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }
    public String toString() {
        return numerator + "/" + denominator;
    }
}

Now you try

• Use a superclass array, add a new subclass, and override toString().
• A hidden Harness checks that the right version runs for each object.
• Press Run to compile, then Check answer. Your code runs on the server, so even the first run is fast.