Polymorphism

Lesson 0009 — 35 min read

Polymorphism — "many forms." The same method or object behaves differently depending on context. Two types: compile-time (static) and run-time (dynamic).

1. Compile-Time Polymorphism (Static)

The method to call is resolved at compile time based on signature (name + parameters). Achieved via method overloading. Also called early binding.

Note: return type alone cannot differentiate overloaded methods.

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

Calculator calc = new Calculator();
System.out.println(calc.add(5, 3));     // int version
System.out.println(calc.add(5.5, 3.3)); // double version

class Calculator {
public:
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
};

Calculator calc;
cout << calc.add(5, 3) << endl;       // int version
cout << calc.add(5.5, 3.3) << endl;   // double version

class Calculator:
    def add(self, a, b):
        return a + b  # works for both — Python is dynamically typed

calc = Calculator()
print(calc.add(5, 3))       # ints
print(calc.add(5.5, 3.3))   # floats

Keypoint: Compiler chooses the right method at compile time by matching argument types. Faster (early binding). No runtime overhead.

2. Run-Time Polymorphism (Dynamic)

The method to call is resolved at runtime based on the actual object type, not the reference type. Achieved via method overriding. Also called late binding or dynamic method dispatch.

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

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

Animal ref = new Dog();   // Animal reference, Dog object
ref.sound();              // "Dog barks" — resolved at runtime

class Animal {
public:
    virtual void sound() { cout << "Animal makes a sound" << endl; }
};

class Dog : public Animal {
public:
    void sound() override { cout << "Dog barks" << endl; }
};

Animal* ptr = new Dog();   // Animal pointer, Dog object
ptr->sound();              // "Dog barks" — vtable lookup at runtime
delete ptr;

class Animal:
    def sound(self):
        print("Animal makes a sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")

myAnimal = Dog()
myAnimal.sound()    # "Dog barks" at runtime

Keypoint: JVM/compiler generates code that checks the actual object type at runtime and dispatches to the correct overridden method. Slightly slower (vtable/dispatch table lookup).

Comparison: Compile-Time vs Run-Time

Why Runtime Polymorphism Matters

It lets you write code that works on a parent reference but calls the child's implementation. This is the foundation of:

• Strategy pattern — swap algorithms at runtime
• Dependency injection — pass any implementation of an interface
• Collections — List<String> list = new ArrayList<>()

class A {
    void show() { System.out.println("A"); }
}

class B extends A {
    void show() { System.out.println("B"); }
}

class C extends A {
    void show() { System.out.println("C"); }
}

A[] arr = {new A(), new B(), new C()};
for (A x : arr) x.show();

Notes

Primary source: Oracle Java Tutorials — Polymorphism. Ask me anything that's unclear.

Questions? Ask your agent — you can follow up on any concept, quiz answer, or how this applies to a specific coding problem. Review the Java glossary or syntax quick reference for a compressed overview.