Polymorphism: dynamic binding, upcasting, downcasting

Polymorphism means “the same call, different behavior on a different object”. You put a circle, a square and a triangle in a Shape array; you call area() on all of them and each computes its own area. The hardest output questions in the exam come from this topic: a variable of the superclass type, a subclass object, and code with super and casts sprinkled in. You solve all of them by asking two questions: what does the compiler allow and which version runs at run time.

Golden rules:

1. The compiler looks at the type of the variable (static type). You cannot call a method that is not in the type of the variable.
2. The JVM looks at the type of the object (dynamic type). For overridden methods, the object’s version runs.
3. Upcasting is automatic, downcasting needs a cast. If the cast is wrong, ClassCastException at run time.
4. Dynamic binding applies only to overridden instance methods. Fields, static methods and private methods are chosen by the type of the variable.

Static type and dynamic type

Animal a = new Lion();

There are two types in this line. The type of the variable a is Animal (static type, known at compile time). The type of the object it points to is Lion (dynamic type, known at run time). This assignment is valid because every Lion is an Animal (is-a). Conversely, Lion l = new Animal(); does not compile.

The hierarchy we will use in the examples:

class Animal {
    void speak() { System.out.println("Animal speaks"); }
}
class Cat extends Animal {
    @Override void speak() { System.out.println("Meow"); }
    void purr() { System.out.println("Purr"); }
}
class Lion extends Cat {
    @Override void speak() { System.out.println("Roar"); }
}

Dynamic binding

When you call an overridden method, which version runs is decided while the program is running, by looking at the object. This is called dynamic binding (or late binding).

Animal a = new Lion();
a.speak();
Animal b = new Cat();
b.speak();
((Cat) b).purr();

Roar
Meow
Purr

You see the real power in arrays and method parameters. Below, Shape.toString() is written only once, but the name() and area() inside it behave differently on each object:

class Shape {
    String name() { return "Shape"; }
    double area() { return 0; }
    public String toString() { return name() + " area=" + area(); }
}
class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override String name() { return "Circle"; }
    @Override double area() { return Math.PI * r * r; }
    double diameter() { return 2 * r; }
}
class Square extends Shape {
    double s;
    Square(double s) { this.s = s; }
    @Override String name() { return "Square"; }
    @Override double area() { return s * s; }
}

Shape[] shapes = { new Circle(1), new Square(2), new Shape() };
for (Shape s : shapes) System.out.println(s);

Circle area=3.141592653589793
Square area=4.0
Shape area=0.0

If you add a new Triangle class, you do not need to touch this loop. That is the real benefit of polymorphism: the code is written against the superclass type and keeps working as new subtypes are added.

Mixed calls with super

super.a() redirects only that one call to the superclass version. If another method is called inside the superclass method (b() is really this.b()), this is still the subclass object and dynamic binding applies again.

class First {
    void a() { System.out.println("First.a"); b(); }
    void b() { System.out.println("First.b"); }
}
class Second extends First {
    @Override void a() { System.out.println("Second.a"); super.a(); }
    @Override void b() { System.out.println("Second.b"); }
}
First f = new Second();
f.a();

Second.a
First.a
Second.b

f.a()          object is Second → Second.a        "Second.a"
  super.a()    explicitly First.a                  "First.a"
    this.b()   this = Second object → Second.b    "Second.b"

Upcasting and downcasting

Downcasting involves two separate checks:

1. Compile time: are the types on the same inheritance line? (Cat) animalRef compiles. Between sibling classes, for example (Dog) catRef, it does not compile: incompatible types: Cat cannot be converted to Dog.
2. Run time: is the object really of that type (or a subtype of it)? If not, ClassCastException.

try {
    Animal an = new Animal();
    Cat ct = (Cat) an;     // compiles, but the object is not a Cat
    ct.purr();
} catch (ClassCastException e) {
    System.out.println("ClassCastException");
}

ClassCastException

PITFALL · do not assume it will run just because it compiles. In “Find the error” questions, first decide whether it is a compile error or a run-time error. A cast from Animal to Cat always compiles; whether it blows up depends on the object.

instanceof

x instanceof T returns true if the object x points to is of type T or a subtype of T. It is used as a check before a downcast.

Animal l = new Lion();
System.out.println(l instanceof Animal);
System.out.println(l instanceof Cat);
System.out.println(l instanceof Lion);
Animal plain = new Animal();
System.out.println(plain instanceof Cat);
Animal nul = null;
System.out.println(nul instanceof Animal);

true
true
true
false
false

The classic pattern and its short form available since Java 16 (pattern matching):

static void describe(Shape s) {
    System.out.print(s.name());
    if (s instanceof Circle) {            // classic
        Circle c = (Circle) s;
        System.out.print(" d=" + c.diameter());
    }
    System.out.println();
}
describe(new Circle(1.5));
describe(new Square(3));

Shape sh = new Circle(2);
if (sh instanceof Circle cc)              // check + cast in one line
    System.out.println("r=" + cc.r);

Circle d=3.0
Square
r=2.0

TIP · an instanceof chain smells bad. If you are writing if (s instanceof Circle) ... else if (s instanceof Square) ..., you should usually put that job in Shape as a method and override it. The phrase “use polymorphism” in the exam asks for exactly this.

Overload and override together

The hardest type of output question. Solve it in two steps:

1. Compile time, signature choice: the static types of the arguments decide which parameter list is called (overload).
2. Run time, version choice: the overridden version of that signature in the object’s actual class runs.

class X {
    void m(Object o) { System.out.println("X.m(Object)"); }
    void m(String s) { System.out.println("X.m(String)"); }
}
class Y extends X {
    @Override void m(Object o) { System.out.println("Y.m(Object)"); }
}
X obj = new Y();
obj.m("hi");          // signature m(String); Y did not override it
Object o = "hi";
obj.m(o);             // signature m(Object); Y overrode it
new X().m(o);

X.m(String)
Y.m(Object)
X.m(Object)

Even though o actually holds a String, the type of the variable (Object) is used when choosing the signature.

Things without dynamic binding

Animal.info();        // static
Animal c2 = new Cat();
c2.info();            // the object is a Cat but static: Animal's

Animal info
Animal info

Common mistakes

class Animal { void speak() { System.out.println("Animal speaks"); } }
class Cat extends Animal { @Override void speak() { System.out.println("Meow"); } }
class Lion extends Cat { @Override void speak() { System.out.println("Roar"); } }
// in main:
Animal a = new Lion();
a.speak();

class Animal { void speak() { } }
class Cat extends Animal { void purr() { } }
// in main:
Animal a = new Cat();
a.purr();

Animal a = new Animal();
Cat c = a;

Animal an = new Animal();
Cat ct = (Cat) an;
ct.purr();

class Animal { }
class Cat extends Animal { }
class Dog extends Animal { }
// in main:
Cat c = new Cat();
Dog d = (Dog) c;

Animal l = new Lion();          // Lion extends Cat extends Animal
System.out.println(l instanceof Cat);
Animal plain = new Animal();
System.out.println(plain instanceof Cat);
Animal nul = null;
System.out.println(nul instanceof Animal);

class First {
    void a() { System.out.println("First.a"); b(); }
    void b() { System.out.println("First.b"); }
}
class Second extends First {
    @Override void a() { System.out.println("Second.a"); super.a(); }
    @Override void b() { System.out.println("Second.b"); }
}
// in main:
First f = new Second();
f.a();

class X {
    void m(Object o) { System.out.println("X.m(Object)"); }
    void m(String s) { System.out.println("X.m(String)"); }
}
class Y extends X {
    @Override void m(Object o) { System.out.println("Y.m(Object)"); }
}
// in main:
X obj = new Y();
obj.m("hi");
Object o = "hi";
obj.m(o);

class Animal { static void info() { System.out.println("Animal info"); } }
class Cat extends Animal { static void info() { System.out.println("Cat info"); } }
// in main:
Animal c = new Cat();
c.info();

Shape[] shapes = { new Circle(1), new Square(2), new Shape() };
for (Shape s : shapes) System.out.println(s);
// Shape.toString() returns name() + " area=" + area();
// Circle and Square override name() and area(), Shape returns "Shape" and 0

public static double totalArea(Shape[] shapes) {
    double sum = 0;
    for (Shape s : shapes) {
        sum += s.area();     // dynamic binding
    }
    return sum;
}