Runtime Polymorphism and Dynamic Binding

Why We Need Runtime Polymorphism

Imagine a checkout that accepts card, UPI and wallet payments. Without polymorphism, the checkout needs an if/else chain that tests which kind of payment it has, and every new payment type means editing that chain. With runtime polymorphism, the checkout calls payment.pay(amount) on a Payment reference and each subclass does its own thing. New payment types are new classes; the checkout code never changes. The same pattern drives drawing a list of Shapes, starting any Vehicle, or a framework calling the run() method of whatever task you give it.

The Three Ingredients: Inheritance, Overriding and Upcasting

Runtime polymorphism needs three things working together. There must be an inheritance (or interface) relationship, the child must override the method, and the call must go through a parent-type reference that holds a child object. That last step is called upcasting: Animal a = new Dog();. Upcasting is implicit and always safe, because every Dog is an Animal. The trade-off is that the compiler now only lets you call methods that Animal declares; a Dog-only method such as fetch() is out of reach through a.

Static Binding vs Dynamic Binding

Java resolves method calls in one of two ways. Static binding (also called early binding) happens at compile time and applies to private, static, and final methods, along with all fields — the compiler already knows exactly which method or field will be used, based purely on the declared (reference) type. Dynamic binding (late binding) happens at runtime and applies to overridden instance methods — the JVM looks at the actual object on the heap, not the reference type used to call it, and dispatches to that object's overridden version.

Virtual Method Invocation

When you call an instance method through a superclass reference variable that actually points to a subclass object, the JVM performs virtual method invocation: it inspects the real object's class at runtime and calls the most specific overriding version available in that object's actual class, walking up the inheritance chain only if no override exists at that level. This is why a Shape reference holding a Circle object calls Circle's area(), not Shape's.

Fields Are NOT Polymorphic

This is one of the most important and most frequently tested distinctions in Java: fields are resolved using static binding based on the reference type, not the object's actual type, even when a subclass declares a field with the same name (field hiding rather than overriding). Only instance methods participate in dynamic, runtime polymorphism — fields never do. Accessing obj.field through a superclass-typed reference always returns the superclass's field, regardless of what the object underneath actually is.

• Overridden instance methods: resolved by the object's actual runtime type (dynamic binding).
• Fields, static methods, and private/final methods: resolved by the reference's declared compile-time type (static binding).
• This asymmetry is why polymorphism is described as applying to "methods, not fields."

Why static, final and private Methods Are Not Polymorphic

Dynamic dispatch only has something to choose between when a method can be overridden. None of these three can, so the compiler binds them early.

• static methods belong to the class. A child's static method with the same signature hides the parent's, and a call through a parent reference runs the parent's version.
• final methods cannot be overridden, so there is only ever one version to call.
• private methods are not inherited; a same-named method in the child is a separate method that a parent reference cannot even see.

Downcasting and the instanceof Operator

To call a child-only method on an upcast reference, you cast back down: Dog d = (Dog) a;. Downcasting is explicit because it can fail. The compiler accepts any cast between related types, but if the object is not really a Dog, the JVM throws ClassCastException at runtime. Guard the cast with instanceof, which returns true only when the object is that type (or a subtype). Since Java 16 the check and the cast can be written together as if (a instanceof Dog d) { d.fetch(); }. If you find yourself downcasting often, it usually means the method belongs in the parent type as an overridable method.

Runtime Polymorphism with Interfaces and Abstract Classes

Runtime polymorphism does not need a concrete parent class. An abstract class can declare abstract double area(); with no body, which forces every concrete subclass (Circle, Rectangle) to override it. An interface such as Vehicle declares void start();, and each implementing class (Car, Bike) provides the body. In both cases you program against the general type — Shape s, Vehicle v — and the JVM dispatches to the real object's implementation. This is the style most real Java code and frameworks use.

Compile-Time vs Runtime Polymorphism

• Achieved by: compile-time uses method overloading; runtime uses method overriding.
• Decided by: compile-time uses the declared types of the arguments; runtime uses the actual class of the object.
• Binding: compile-time is static (early) binding; runtime is dynamic (late) binding.
• Inheritance needed: not for overloading; yes (a class or an interface) for overriding.
• Flexibility: overloading offers convenient variants of one operation; overriding lets new types plug in without changing calling code.

Examples

class Shape {
    String label = "Shape";

    String describe() {
        return "A generic shape";
    }
}

class Square extends Shape {
    String label = "Square"; // hides Shape.label, does not override it

    @Override
    String describe() {
        return "A square";
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Shape ref = new Square(); // superclass reference, subclass object

        System.out.println(ref.describe()); // dynamic binding -> Square's version
        System.out.println(ref.label);       // static binding -> Shape's field
    }
}

A square
Shape

public class ShapeDemo {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(1), new Rectangle(2, 3) };
        for (Shape s : shapes) {
            System.out.printf("%s area = %.2f%n", s.name(), s.area());
        }
    }
}

abstract class Shape {
    abstract double area();      // no body: every subclass must override it

    String name() {
        return getClass().getSimpleName();
    }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }

    @Override
    double area() { return Math.PI * r * r; }
}

class Rectangle extends Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }

    @Override
    double area() { return w * h; }
}

Circle area = 3.14
Rectangle area = 6.00

public class VehicleDemo {
    static void startTrip(Vehicle v) { // works for every Vehicle, now and later
        v.start();
    }

    public static void main(String[] args) {
        startTrip(new Car());
        startTrip(new Bike());
    }
}

interface Vehicle {
    void start();
}

class Car implements Vehicle {
    @Override
    public void start() { System.out.println("Car: turn key, engine starts"); }
}

class Bike implements Vehicle {
    @Override
    public void start() { System.out.println("Bike: kick start"); }
}

Car: turn key, engine starts
Bike: kick start

public class CastDemo {
    public static void main(String[] args) {
        Animal a = new Dog();          // upcasting: implicit and always safe
        a.sound();                     // Dog's override runs
        // a.fetch();                  // compile error: Animal has no fetch()

        if (a instanceof Dog d) {      // check, then downcast (Java 16+ pattern)
            d.fetch();
        }

        Animal c = new Cat();
        Dog wrong = (Dog) c;           // compiles, but fails at runtime
    }
}

class Animal {
    void sound() { System.out.println("Some sound"); }
}

class Dog extends Animal {
    @Override
    void sound() { System.out.println("Woof"); }

    void fetch() { System.out.println("Dog fetches the ball"); }
}

class Cat extends Animal {
    @Override
    void sound() { System.out.println("Meow"); }
}

Woof
Dog fetches the ball
Exception in thread "main" java.lang.ClassCastException: class Cat cannot be cast to class Dog (Cat and Dog are in unnamed module of loader 'app')
    at CastDemo.main(CastDemo.java:12)

Exercise

This program prints parent and then child method: the method call is polymorphic, but the field access is not. Add an overridable getName() method to both classes and use it in main so the first line prints child.

Expected output: child then child method

class Parent {
    String name = "parent";

    String who() {
        return "parent method";
    }
}

class Child extends Parent {
    String name = "child";

    @Override
    String who() {
        return "child method";
    }
}

public class BindingDemo {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.name);
        System.out.println(p.who());
    }
}

class Parent {
    String name = "parent";

    String getName() {
        return name;
    }

    String who() {
        return "parent method";
    }
}

class Child extends Parent {
    String name = "child";

    @Override
    String getName() {
        return name;
    }

    @Override
    String who() {
        return "child method";
    }
}

public class BindingDemo {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.getName()); // child
        System.out.println(p.who());     // child method
    }
}

Quick quiz

Interview questions

Go deeper

• Method Overriding
• instanceof and Downcasting
• Method Overloading vs Method Overriding: A Comparison