Polymorphism In OOPS: What is Polymorphism [Detailed Explanation]

Object-oriented programming (OOP) is a popular programming model that revolves around the concept of objects and classes. It allows developers to make their programs in a way that simulates real-world entities, making code more instinctive and maintainable.

OOP has 4 primary pillars:

1. Encapsulation
2. Inheritance
3. Abstraction
4. Polymorphism

Well today, we’ll focus on Polymorphism, a key principle that adds flexibility and reusability to object-oriented designs. The word “Polymorphism” comes from Greek, meaning "many shapes."

Polymorphism in Object-Oriented Programming (OOP) lets us treat different types of objects as if they are the same type. For example, a person who plays various roles, like being a father, brother, friend, or son. They adjust their behavior based on the role they are playing at the moment.

This ability makes it easier for programs to work with different kinds of data and classes. It helps keep the code organized and makes it simpler to update and maintain.

This blog will explain what Polymorphism is, why it’s important, and how it is applied in programming.

Why is Polymorphism Important in OOP?

Polymorphism is one of the main features of object-oriented programming (OOP) which makes it powerful. Due to Polymorphism, a developer can write flexibly as well as they can reuse and maintain their codes.

By enabling objects of different types to be treated as instances of a common parent class, Polymorphism simplifies complex systems and makes code more adaptable.

But, did you know how important this is in coding?

Here are 3 key reasons why Polymorphism is important in OOP:

1. Code Reusability and Flexibility:

• Polymorphism helps you write more generic functions or classes, to work with objects of different types which means you can reuse the same code for various situations.
• For example, rather than writing separate functions for handling different shapes (like circles, rectangles, and triangles), you can write one function that works for any shape, as long as they share a common interface.

2. Improved Maintainability:

• With Polymorphism, you can modify or add new functionality without making a new code. Since objects of different kinds can share the same methods, it becomes very easy to extend and maintain your code.
• For instance, if you create a new subclass that becomes from an existing class, it can automatically use the same methods that were written for the parent class. This allows you to build on your codebase, keeping things organized and easier to manage.

3. Simplifying Complex Systems:

• Polymorphism allows different objects to be handled through a single uniform interface, which simplifies the design of complex systems.
• For eg, a system that manages various employee types like developers, managers, and interns who have their own specific tasks. Instead of creating separate systems for each type, Polymorphism allows you to design one interface for all employees and then handle the differences within the subclasses.

What are the Types of Polymorphism in OOP?

Polymorphism in object-oriented programming can be classified into two main types:

• Compile-time Polymorphism
• Runtime Polymorphism

Each type plays a crucial role in how objects interact and perform different tasks within a program.

So let's dive a bit deeper into the types of Polymorphism, to make you understand more smoothly.

What is Compile-Time Polymorphism (Static Polymorphism)?

Compile-time Polymorphism occurs when the method to be executed is determined at compile time before the program runs. This type of Polymorphism is mainly achieved through method overloading and operator overloading.

1) Method Overloading

When a class has multiple methods with the same name but different parameters (e.g., different types or numbers of parameters), these methods perform different tasks depending on the input given to them. The compiler decides which method to call based on the parameters provided.

Example:

Imagine a class with several methods named calculateArea(). One version of the method calculates the area of a circle when given the radius, while another version calculates the area of a rectangle when given the length and width. This allows the program to handle different tasks with the same method name, making the code cleaner and more intuitive.

public class Shape {
    public double calculateArea(double radius) {
        return 3.14 * radius * radius; // Circle
    }

    public double calculateArea(double length, double width) {
        return length * width; // Rectangle
    }
}

2) Operator Overloading

It allows operators (such as +, -, or *) to be redefined to work with user-defined data types. This feature is common in languages like C++ and Python. It lets a single operator perform different functions depending on the context.

Example:

In many languages, the + operator can be overloaded to both add numbers and concatenate strings. For example, 3 + 5 will result in 8, while "Hello" + " World" will result in "Hello World". This flexibility allows operators to work with various data types in a meaningful way.

#include <iostream>
using namespace std;

class Complex {
public:
    int real, imag;
    Complex(int r, int i): real(r), imag(i) {}

    // Operator overloading for '+'
    Complex operator + (Complex const &obj) {
        Complex res(real + obj.real, imag + obj.imag);
        return res;
    }
};

int main() {
    Complex c1(3, 2), c2(1, 7);
    Complex c3 = c1 + c2; // Adds real and imaginary parts
    cout << c3.real << " + i" << c3.imag << endl;
    return 0;
}

What is Runtime Polymorphism?

Runtime Polymorphism, also known as dynamic Polymorphism, occurs when the method to be executed is determined during the execution (or runtime) of the program. 

Unlike compile-time Polymorphism, which is resolved during the compilation phase, runtime Polymorphism provides greater flexibility and is commonly achieved through method overriding.

1) Method Overriding

It occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. In this case, the subclass "overrides" the method to give its own specialized behavior while still maintaining the same method signature (name and parameters).

Example:

Imagine you have a superclass called Animal with a method makeSound(). The Dog subclass can override the makeSound() method to provide a specific implementation for dogs.

java

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

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

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.makeSound(); // Output: Dog barks
    }
}

In this example, even though the object myAnimal is of type Animal, the method makeSound() from the Dog class is called because the actual object is an instance of Dog. This is runtime Polymorphism in action.

2) Late Binding vs. Early Binding

Early binding, also known as compile-time binding, refers to method calls that are resolved at compile time. This happens with method overloading, where the compiler knows exactly which method to call based on the method signature.

Late binding, also called runtime binding, occurs during the execution of the program, and the method to be called is determined at runtime. This happens with method overriding, where the decision about which method implementation to execute depends on the actual object type at runtime, not the reference type.

Advantages of Runtime Polymorphism:

• Flexibility: Late binding allows the program to decide which method to invoke at runtime, providing more flexibility in scenarios where behavior needs to be determined dynamically.
• Code Extension: Runtime Polymorphism enables the addition of new subclasses without modifying existing code. You can extend systems by adding new types with overridden methods, and the program will still function seamlessly.

Also Read: Polymorphism in Java

What are the Examples of Polymorphism in OOP?

Polymorphism in programming can be confusing for so many people at first, but in our everyday lives, we are naturally experiencing it without realizing it.

Let’s explore some relatable, real-world examples of Polymorphism, where one action or command can have different results depending on the situation.

1. Switch Example:

• Flipping a light switch is a single action, but depending on the room, it may turn on an overhead light, a lamp, or under-cabinet lighting. Just like Polymorphism, the same action produces different results based on the situation.

2. Call Example: 

• When you make a phone call, the outcome varies based on who you’re calling. A call to family leads to a casual chat, while a call to a restaurant results in making a reservation. This is similar to how, in programming, the same function can behave differently depending on the object.

3. Eat Example:

• Eating can be done in different ways—biting into an apple or using a spoon for soup. The action is the same (eating), but the method changes based on what you’re eating, just like method overloading in Polymorphism.

4. School Example: 

• In schools, a teacher teaches a class, but the subject varies like math, history, or science. The core action (teaching) is the same, but the content changes based on the subject, similar to how Polymorphism works with different object types in OOP.

What are the Common Misconceptions About Polymorphism?

Polymorphism is a simple concept in object-oriented programming, but sometimes people misunderstand this. They get confused with other concepts and think that it has some drawbacks while using which is not accurate.

So, let’s clear up some misconceptions about Polymorphism.

1) Polymorphism is Not the Same as Inheritance:

• One common misconception is that Polymorphism and inheritance are the same. While they both are related, but they are different. 
• Inheritance allows a child class to inherit properties and methods from a parent class, creating a class hierarchy.
• Whereas Polymorphism enables methods to perform different actions based on the situation, even if they share the same name.
• Inheritance focuses on class relationships, while Polymorphism emphasizes how objects behave differently.

2) Polymorphism Does Not Reduce Performance:

• Another misconception is that using runtime Polymorphism makes programs slower. While it’s true that runtime Polymorphism can involve a little extra work, that is why modern compilers are designed to handle this efficiently. 
• They optimize the code in a way that minimizes any performance impact. So, you can use Polymorphism confidently without worrying about significantly slowing down your program.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Polymorphism in Real-world Applications

Polymorphism plays a significant role in various real-world applications, making software development more efficient and organized. Explore how Polymorphism is used in software development to create scalable and maintainable applications. 

Also, take a look at popular frameworks that utilize Polymorphism as a core part of their architecture.

Application in Software Development:

• In real-world software development, Polymorphism helps developers create applications that are easy to scale and maintain. They can add new features or change existing ones without needing to rewrite the code.
• For example, an e-commerce application can have different types of payment methods (like credit cards, PayPal, and bank transfers) that share a common interface for processing payments which makes it very easy to manage the application.

Now, that you have seen the real-world applications of Polymorphism, check out the popular frameworks below.

Many popular frameworks rely on Polymorphism to function effectively. These frameworks highlight how Polymorphism is a key feature that enhances software applications.

Some of the  most popular frameworks are:

1. Spring Framework (Java):

• Uses Polymorphism to manage various component types.
• Allows components to be easily swapped in and out.

2. Django (Python):

• Utilizes Polymorphism in its models and views.
• Enables developers to create flexible and reusable code.

What are the key differences between Polymorphism, Inheritance, and Encapsulation?

Polymorphism, inheritance, and encapsulation are fundamental concepts in object-oriented programming (OOP) that work together to create more efficient and organized code. Understanding the differences between these concepts is essential for any developer, as each serves a unique purpose in building software applications. 

Below is a brief comparison highlighting their definitions and key benefits.

Conclusion

Polymorphism is an important concept in object-oriented programming that enhances flexibility, code reusability, and maintainability. By allowing objects of different types to be treated as a common type, Polymorphism enables developers to write adaptable and efficient code.

We explored compile-time and runtime Polymorphism, clarified common misconceptions, and highlighted the differences between Polymorphism, inheritance, and encapsulation. Additionally, we examined real-world applications where Polymorphism streamlines development.

Understanding Polymorphism empowers developers to create strong software solutions that evolve easily, leading to more organized and maintainable code. 

Sign up for Upgrad's free course on Java Object-oriented Programming to enhance your programming skills and learn key concepts like compile-time and runtime Polymorphism. Boost your coding expertise with practical examples, enroll today!

Browse our top-rated Software Engineering courses in the table below—each course is crafted to fast-track your career with industry-relevant skills, practical projects, and expert guidance to make you stand out in the tech field!

Master the in-demand Software Development skills listed below—each skill is essential for building robust applications, optimizing performance, and staying competitive in the ever-evolving tech industry!

Dive into our must-read software articles below—packed with expert advice, practical insights, and the latest innovations to keep you informed and elevate your software development skills!

Take advantage of our free Software Development courses below—each one is designed to equip you with the essential skills and knowledge you need to thrive in the tech industry, all at no cost!