Polymorphism in Java: An Overview

Compile-Time (Static) Polymorphism — Method Overloading

Overloading lets a class define multiple methods with the same name but different parameter lists (different number, type, or order of parameters). The compiler decides which version to call by matching the arguments at compile time — hence "static" or "compile-time" polymorphism. Overloaded methods can differ in return type too, but return type alone is never enough to distinguish them.

Runtime (Dynamic) Polymorphism — Method Overriding

Overriding lets a subclass provide its own implementation of a method already defined in its superclass, using the exact same signature. Which version actually runs is decided at runtime, based on the real (runtime) type of the object being referenced — not the type of the reference variable. This is what allows a single line of code like animal.makeSound() to produce different behavior depending on whether "animal" actually refers to a Dog or a Cat object.

Why the Distinction Matters

Compile-time polymorphism is about convenience and readability — one intuitive method name covering several related use cases. Runtime polymorphism is far more powerful architecturally: it is the mechanism behind interfaces, abstract classes, and extensible frameworks, because it lets code work with a general supertype while automatically running the correct specific behavior for whatever object is actually supplied at runtime.

How the JVM Picks the Method: Dynamic Method Dispatch

A call such as animal.sound() is handled in two steps. At compile time, the compiler looks only at the declared type of the variable (Animal) and checks that this type has a sound() method; if it does not, the code does not compile, whatever the object will be. At runtime, the JVM looks at the class of the actual object and runs the most specific version of sound() it finds, starting at that class and walking up through its parents. This runtime lookup is called dynamic method dispatch. It is why the declared type decides which methods you may call, while the object decides which code actually runs.

Upcasting and Downcasting

Storing a Dog in an Animal variable is an upcast. It is always safe, so Java does it automatically, and it is what makes polymorphism possible: a list of Animal can hold dogs, cats and any future subclass. Going the other way, from Animal back to Dog to call a dog-only method such as fetch(), is a downcast. It needs an explicit cast and can fail: if the object is really a Cat, the JVM throws ClassCastException. Check first with instanceof; since Java 16 you can check and cast in one step with if (a instanceof Dog d) { d.fetch(); }. Frequent downcasting is often a sign that the behaviour belongs in an overridden method instead.

What Is Not Polymorphic

Only instance methods that are inherited and overridable take part in runtime dispatch. Everything else is decided by the compiler from the declared type:

• static methods belong to the class, not the object. A subclass may declare a static method with the same signature, but that hides the parent's method rather than overriding it, and @Override on it is a compile error.
• private methods are not inherited, so a subclass method with the same name is simply a new, unrelated method.
• final methods cannot be overridden at all; the compiler reports "overridden method is final".
• Fields are never overridden. A subclass field with the same name hides the parent's, and which one you read depends on the variable's declared type.
• Overload selection also uses declared types: with print(Animal) and print(Dog), calling print(a) on an Animal variable picks print(Animal) even when a holds a Dog.

Polymorphism with Interfaces and Abstract Classes

In real projects the parent type is usually an interface or an abstract class rather than a concrete class. An interface such as PaymentMethod states what every payment can do (pay(amount)) without saying how. Card, UPI and wallet payments each implement it differently, and the checkout code works with PaymentMethod only, so adding a new payment type needs no change there. An abstract class sits in between: it can implement the steps that are the same for every subclass and leave one step abstract, as OnlinePayment does below with transfer(). Overriding methods may also narrow the return type, for example a copy() that returns Shape in the parent and Circle in the child. This is called a covariant return type and is covered in the Method Overriding lesson.

Examples

// --- Compile-time polymorphism: overloading ---
class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

// --- Runtime polymorphism: overriding ---
class Animal {
    void makeSound() { System.out.println("Some generic animal sound"); }
}

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

public class PolymorphismOverviewDemo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));       // resolved at compile time -> int version
        System.out.println(calc.add(2.5, 3.5));   // resolved at compile time -> double version

        Animal a = new Dog();      // reference type Animal, actual object Dog
        a.makeSound();             // resolved at RUNTIME based on actual object -> Woof!
    }
}

5
6.0
Woof!

import java.math.BigDecimal;
import java.util.List;

public class PaymentDemo {
    public static void main(String[] args) {
        List<PaymentMethod> methods = List.of(
                new CardPayment("4111111111111111"),
                new UpiPayment("asha@okbank"),
                new WalletPayment(new BigDecimal("300.00")));

        BigDecimal amount = new BigDecimal("499.00");
        for (PaymentMethod method : methods) {        // one loop, three behaviours
            System.out.println(method.name() + ": " + method.pay(amount));
        }
    }
}

interface PaymentMethod {
    String pay(BigDecimal amount);

    default String name() {                           // shared default, can be overridden
        return getClass().getSimpleName();
    }
}

abstract class OnlinePayment implements PaymentMethod {
    // Every online payment is formatted the same way; only the transfer differs
    @Override
    public final String pay(BigDecimal amount) {
        return "Rs." + amount + " " + transfer(amount);
    }

    protected abstract String transfer(BigDecimal amount);
}

class CardPayment extends OnlinePayment {
    private final String cardNumber;
    CardPayment(String cardNumber) { this.cardNumber = cardNumber; }

    @Override
    protected String transfer(BigDecimal amount) {
        return "charged to card ending " + cardNumber.substring(cardNumber.length() - 4);
    }
}

class UpiPayment extends OnlinePayment {
    private final String upiId;
    UpiPayment(String upiId) { this.upiId = upiId; }

    @Override
    protected String transfer(BigDecimal amount) {
        return "requested from " + upiId;
    }

    @Override
    public String name() { return "UPI"; }
}

class WalletPayment implements PaymentMethod {
    private BigDecimal balance;
    WalletPayment(BigDecimal balance) { this.balance = balance; }

    @Override
    public String pay(BigDecimal amount) {
        if (balance.compareTo(amount) < 0) {
            return "declined, wallet balance is Rs." + balance;
        }
        balance = balance.subtract(amount);
        return "paid from wallet";
    }
}

CardPayment: Rs.499.00 charged to card ending 1111
UPI: Rs.499.00 requested from asha@okbank
WalletPayment: declined, wallet balance is Rs.300.00

public class TrickyOutput {
    static void print(Animal a) { System.out.println("print(Animal)"); }
    static void print(Dog d)    { System.out.println("print(Dog)"); }

    public static void main(String[] args) {
        Animal a = new Dog();                 // upcast: automatic

        a.sound();                            // Q1
        print(a);                             // Q2
        System.out.println(a.legs);           // Q3
        a.describe();                         // Q4

        if (a instanceof Dog d) {             // Q5: check and downcast in one step (Java 16+)
            d.fetch();
        }

        Animal cat = new Cat();
        try {
            Dog wrong = (Dog) cat;            // Q6
            wrong.fetch();
        } catch (ClassCastException e) {
            System.out.println("ClassCastException: " + e.getMessage());
        }
    }
}

class Animal {
    int legs = 4;
    void sound() { System.out.println("Animal sound"); }
    static void info() { System.out.println("Animal.info"); }
    void describe() { info(); }
}

class Dog extends Animal {
    int legs = 3;                             // hides Animal.legs (a three-legged dog)
    @Override void sound() { System.out.println("Woof"); }
    static void info() { System.out.println("Dog.info"); }   // hides, does not override
    void fetch() { System.out.println("Dog fetches"); }
}

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

Woof
print(Animal)
4
Animal.info
Dog fetches
ClassCastException: class Cat cannot be cast to class Dog (Cat and Dog are in unnamed module of loader ...)

Q1 Woof: sound() is an overridden instance method, so the Dog object decides.
Q2 print(Animal): overloads are chosen at compile time from the declared type Animal.
Q3 4: fields are not overridden; a.legs reads the field declared in Animal.
Q4 Animal.info: static methods are hidden, not overridden, so describe() calls Animal's.
Q5 the pattern match succeeds because the object really is a Dog.
Q6 the object is a Cat, so the cast fails at runtime, not at compile time.

Exercise

Create two kinds of notification that share a parent type. Each overrides send() to return its own text. Store one of each in an array of the parent type and print the result of send() for every element.

Expected output: Email sent then SMS sent

class Notification {
    String send() {
        return "Notification sent";
    }
}

// TODO: class EmailNotification extends Notification, returning "Email sent"
// TODO: class SmsNotification extends Notification, returning "SMS sent"

public class NotifyDemo {
    public static void main(String[] args) {
        Notification[] queue = { new EmailNotification(), new SmsNotification() };
        // TODO: loop over the queue and print send() for each element
    }
}

class Notification {
    String send() {
        return "Notification sent";
    }
}

class EmailNotification extends Notification {
    @Override
    String send() {
        return "Email sent";
    }
}

class SmsNotification extends Notification {
    @Override
    String send() {
        return "SMS sent";
    }
}

public class NotifyDemo {
    public static void main(String[] args) {
        Notification[] queue = { new EmailNotification(), new SmsNotification() };
        for (Notification notification : queue) {
            System.out.println(notification.send());
        }
    }
}

Quick quiz

Interview questions

Go deeper

• Method Overriding
• Runtime Polymorphism and Dynamic Binding
• instanceof and Downcasting