When you think of the word polymorphism, it may sound complicated, but it’s actually one of the most powerful and beautiful concepts in Object-Oriented Programming (OOPs). The definition of polymorphism itself means “many forms” and that is exactly what polymorphism allows us to do with programming.
In this article, I will walk you through polymorphism in OOPs, its types, benefits, real-life examples, and how it works in Java, Python, and C++ with some code examples.
🔑 What is Polymorphism in OOPs?
Polymorphism in OOPs, gives an object the ability to take on many forms. It allows a single interface to be used for different data types or a single method name to behave differently in different contexts.
👉 In simple words; the same function name can perform different tasks.
For example:
- In real life, a person can be a teacher at a school, a customer at a shop, and a parent at home. Same person, but different behaviour based on the context.
That’s exactly what polymorphism in OOPs is doing for objects.
⚡ Types of Polymorphism in OOPs
The two main types of polymorphism are:
Compile-Time Polymorphism (Static Binding): This is known as method overloading and it occurs when two or more methods in the same class have the same name, but only differ in the parameters.
- Example: A method called add(int a, int b) versus a method called add(double a, double b)
Run-Time Polymorphism (Dynamic Binding): This is known as method overriding. This is when a subclass of a class specifies the implementation of a method that has already been defined in the parent class.
- Example: A class called Animal has a method called sound() which has different implementations in subclasses called Dog and Cat.
Polymorphism in Java
Java is arguably the best programming language to explain how polymorphism works in OOPs because Java specifically supports both method overloading and method overriding.
✅ Example of Compile-Time Polymorphism (Overloading)
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println(calc.add(5, 10)); // calls int version
System.out.println(calc.add(5.5, 4.5)); // calls double version
}
}✅ Example of Run-Time Polymorphism (Overriding)
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.sound(); // Output: Dog barks
}
}Here, the same method sound() behaves differently depending on the object type.
🐍 Polymorphism in Python
Python implements polymorphism in OOPs in a very flexible way because python does not force strict type declarations within its implementation of OOP panels.
✅ Example of Polymorphism in Python
class Bird:
def fly(self):
print("Bird can fly")
class Airplane:
def fly(self):
print("Airplane can fly in the sky")
def lift_off(entity):
entity.fly()
bird = Bird()
plane = Airplane()
lift_off(bird) # Bird can fly
lift_off(plane) # Airplane can fly in the sky👉 The function lift_off() works with different objects that implement fly() — this is polymorphism at work.
🖥️ Polymorphism in C++
C++ provides compile-time polymorphism with function overloading and run-time polymorphism with virtual functions.
✅ Example of Runtime Polymorphism in C++
#include <iostream>
using namespace std;
class Animal {
public:
virtual void sound() {
cout << "Animal makes a sound" << endl;
}
};
class Cat : public Animal {
public:
void sound() override {
cout << "Cat meows" << endl;
}
};
int main() {
Animal* a;
Cat c;
a = &c;
a->sound(); // Output: Cat meows
return 0;
}🌍 Real-Life Examples of Polymorphism
- Payment Systems: pay() method may have different implementation for Credit Card, UPI, or PayPal.
- Shapes in Geometry: draw() method may have different implementation for Circle, Square, or Triangle.
- For example: Vehicles: start() method different for Car, Bike, or Truck.
📊 Advantages of Polymorphism in OOPs
- Increases code reusability
- Provides good readability and maintainability
- Provides extensibility (adding a brand new class will not require changing existing code)
- Provides flexibility in design.
🔥 Polymorphism in OOPs vs Other OOP Concepts
Polymorphism works hand-in-hand with:
- Encapsulation – hiding implementation details.
- Inheritance – allowing subclasses to inherit properties and behaviors.
- Abstraction – defining methods without implementation.
Together, these four pillars form the foundation of OOPs.
✅ Final Thoughts
Polymorphism is not something theoretical, it is present in programming everywhere. Whether you are using Java, Python, or C++, learning polymorphism in OOPs will help you to write clean, reusable, and flexible code.
If you are preparing for interviews or coding interviews you will want to remember the following:
- Method Overloading → Compile-Time Polymorphism
- Method Overriding → Run-Time Polymorphism
Polymorphism will become the way you write code the more you practice.
Related Links
