Polymorphism in Java (Compile-time & Runtime)
Polymorphism is one of the four pillars of Object-Oriented Programming (OOP) in Java.
The term “polymorphism” comes from Greek words poly (many) and morph (forms), meaning “many forms.”
In Java, polymorphism allows one action to behave differently based on the object that performs it.
What is Polymorphism?
Polymorphism is the ability of an object to take many forms — the same method name can perform different actions depending on the object or arguments involved.
Types of Polymorphism in Java
1. Compile-time Polymorphism (Static Binding)
Also called Early Binding. The method to be called is decided at compile time based on the method signature (name + parameters).
Achieved through Method Overloading
Method Overloading occurs when multiple methods have the same name, but different parameter lists (different number or type of arguments).
Example: Method Overloading
class MathUtils {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
}
public class Main {
public static void main(String[] args) {
MathUtils m = new MathUtils();
System.out.println(m.add(5, 10)); // calls add(int, int)
System.out.println(m.add(2.5, 3.7)); // calls add(double, double)
System.out.println(m.add(1, 2, 3)); // calls add(int, int, int)
}
}
Output
15
6.2
6
The compiler determines which version of the method to call — at compile time.
2. Runtime Polymorphism (Dynamic Binding)
Also called Late Binding. The method to be executed is determined at runtime based on the object type, not the reference type.
Achieved through Method Overriding
Method Overriding occurs when a subclass provides a specific implementation of a method already defined in its superclass.
Example: Method Overriding
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
void sound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal a; // reference variable of parent type
a = new Dog(); // object of Dog
a.sound(); // Dog's version called
a = new Cat(); // object of Cat
a.sound(); // Cat's version called
}
}
Output
Dog barks
Cat meows
Even though the reference is of type Animal, the method executed depends on the actual object type (Dog or Cat) → runtime decision.
super in Runtime Polymorphism
You can use super in overridden methods to call the parent class version of a method.
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void sound() {
super.sound(); // call parent class method
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
d.sound();
}
}
Output
Animal makes a sound
Dog barks
Compile-time vs Runtime Polymorphism
| Feature | Compile-time (Overloading) | Runtime (Overriding) |
|---|---|---|
| Binding Time | At compile time | At runtime |
| Achieved By | Method Overloading | Method Overriding |
| Parameters | Must be different | Must be same |
| Return Type | Can be different | Usually same |
| Performance | Faster | Slightly slower |
| Inheritance | Not required | Required |
Example – Real-World Use of Polymorphism
Polymorphism is widely used in frameworks, APIs, and real-world applications to write flexible and maintainable code.
Example 1: Web Automation (Selenium Java)
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
// Later switching browser
driver = new FirefoxDriver(); // No change in rest of the code
driver.get("https://example.com");Runtime polymorphism allows driver to work with different browser drivers without modifying the rest of the program.
Example 2: Payment Gateway Processing
class Payment {
void process() { System.out.println("Processing generic payment"); }
}
class CreditCardPayment extends Payment {
@Override
void process() { System.out.println("Processing credit card payment"); }
}
class PayPalPayment extends Payment {
@Override
void process() { System.out.println("Processing PayPal payment"); }
}
public class PaymentDemo {
public static void main(String[] args) {
Payment p = new CreditCardPayment();
p.process(); // Runtime decides actual method
p = new PayPalPayment();
p.process(); // Different behavior, same reference
}
}
Output:
Processing credit card payment
Processing PayPal paymentShows how runtime polymorphism allows using a single reference to handle multiple payment types.