Polymorphism In OOPS: What is Polymorphism [Detailed Explanation]

Polymorphism in OOPs is inseparable and an essential concept of every object-oriented programming language. An object or reference basically can take multiple forms in different instances. As the word suggests, ‘poly’ means ‘many’ and ‘morph’ points at ‘forms’; thus, polymorphism as a whole would mean ‘a property of having many forms.’

The object-oriented programming language processes classes and objects by a single interface. It implements the concepts of function overloading, overriding, and virtual functions. Also, it is typically used for instrumenting inheritance in programming. 

Polymorphism is one of the significant OOPS concepts. Using Polymorphism, you can have various or multiple forms of objects, variables, or methods. There can be varied implementations of the same method as per the class’ need using Polymorphism.

The concept of polymorphism offers great scalability and boosts the code’s readability. You can define polymorphism to have your unique implementation for the same method within the Parent class. Generally, it can be obtained using inheritance which implies that the class must belong to the same hierarchy tree. Knowing more about Polymorphism implementation in the programming world and how you can access it using the class object is necessary.

It denotes an object’s/reference’ ability to adopt several forms in various instances. It uses the concept of function overriding, function overloading, and virtual functions.

Polymorphism is a property using which any message could be delivered to objects of multiple classes. Each object owns the tendency to respond appropriately based on the class properties.

It implies that polymorphism is the method in an OOP language that performs different things based on the class of the object that calls it. For instance example, $rectangle->area() will return the area of a rectangle, but $square->area() will return the area of a square. But $object->area() will have to calculate the area based on which class $object was called.

Why is polymorphism used?

The concept of polymorphism helps you to perform a single action in various ways. It helps you to define one interface and benefit from multiple implementations. The term to explain polymorphism is such that the word “poly” indicates many and “morphs” indicates forms. Hence, it implies many forms.

Benefits of Polymorphism in OOPS:

Polymorphism aids the developer in reusing the program codes. It suggests that the old codes and classes written once, confirmed, and executed can be reused when required. This saves a programmer’s time. Hence, these codes and associated classes may be relevant to other methods.

Only a single variable can be used for storing multiple data types like Float, Int, Long, Double, etc. It simplifies the process of searching and executing the types of variables the users utilize.

You can define polymorphism to simplify code debugging. It assists in maintaining and reducing the coupling among different functionalities.

It benefits programmers with the flexibility to write programs that uses just one method for several executions as required. This method can work inversely for various inputs based on the interface type.

One of the biggest benefits to explain polymorphism is that it allows the programming code to expand itself to use the previous program. Thus, it saves the developers’ effort and time.

The core theory of OOPs languages is also implemented for programming various forms of large execution of codes.

The Polymorphism feature lets programming become more resourceful and faster for code development.

It decreases coupling and maximizes reusability to code a readable program.

Also, Check out our free courses

Read: Polymorphism vs Inheritance

An Example of Polymorphism in OOPs

Polymorphism is the method in an object-oriented programming language that performs different things as per the object’s class, which calls it. With Polymorphism, a message is sent to multiple class objects, and every object responds appropriately according to the properties of the class. 

Following is the code that explains polymorphism clearly:

use warnings;
# Creating package class
package A;
# Creating Constructor
sub new
{
# shift will take package name
# and assign it to variable ‘class’
my $class = shift;
my $self = {
‘name’ => shift,
‘roll_no’ => shift
};
sub method
{
print(“This belongs to class A “);
}
};
package B;
# The @ISA array contains a list
# of that class’s parent classes, if any
my @ISA = (A);

submethod
{
print(“This belongs to class B”);
}
package main;
B->method();
A->method();

Output:

This belongs to class B

This belongs to class A

Learn to build applications like Swiggy, Quora, IMDB and more

Get Software Development Course from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Explanation

For the first output, the method() defined in class B overrides the definition inherited from class A and vice-versa for the second output. This property is useful in extending any pre-existing package’s functionality without rewriting the entire class’s entire definition. Thus, making the job easy for the programmer and the reason for being used widely.

Check out upGrad’s Full Stack Development Bootcamp

Important concepts about Polymorphism in OOPS:

What are the principles of Polymorphism in OOPS?

The dictionary definition of OOP polymorphism relates to the biology principle in which species or organisms can have several different stages or forms. This principle can be applied to object-oriented programming and languages such as Java.

 What is overloading and overriding in Polymorphism?

In OOP polymorphism, overloading happens when two or more methods in one class share the same method name but with unique parameters. It happens when two methods share the same method name and parameters. These are the two common methods for overloading and overriding Polymorphism in the parent and child classes.

What are compile-time and runtime in Polymorphism?

Compile time is when the programming code (like C, C#, Java, Python) is transformed into the machine code i.e. binary code. Runtime is when a program is executing and usually happens after compile time.

Which type of function shows Polymorphism?

Compile time polymorphism is obtained by operator overloading or function overloading. Function overloading is when there are multiple functions with similar names. If varied parameters are used, then these functions are said to be overloaded.

What is a method in OOP?

The method in polymorphism explains that it is a programmed process that is defined as part of a class and incorporated into any object of the particular class. A class and an object can have multiple methods.

Explore our Popular Software Engineering Courses

Types of Polymorphism in Oops

In Object-Oriented Programming (OOPS) language, there are two types of polymorphism as below:

1. Static Binding (or Compile time) Polymorphism, e.g., Method Overloading
2. Dynamic Binding (or Runtime) Polymorphism, e.g., Method overriding

Source

In-Demand Software Development Skills

1. Compile Time or Static Polymorphism

With Method Overloading, static polymorphism is achieved in Object-Oriented Programming languages that allow the programmer to implement various methods. The names they use can be the same, but their parameters are different.

In OOPS, you can attain compile-time polymorphism using method overloading. Java recognized which method to call after checking the corresponding method signature. In the method overloading polymorphism concept, there can be the same method name but a different number of arguments and the return type to execute this. In a nutshell, when the object is limited to its functionality, it is called compile time polymorphism.

In OOPS, you can attain compile-time polymorphism using method overloading. Java recognized which method to call after checking the corresponding method signature. In the method overloading polymorphism concept, there can be the same method name but a different number of arguments and the return type to execute this. In a nutshell, when the object is limited to its functionality, it is called compile time polymorphism.

Certain conditions are conducive to static polymorphism as below:

•       Types of All Parameters should be different.
•       The sequence of the Parameters can be different.
•       The number of parameters of one method should differ from the other method.

In the static binding polymorphism, the matching type and number of arguments invoke the overloaded functions. 

• As all of this information is available during the compile time, the compiler selects the appropriate function. 
• The function overloading does it, and operator overloading is also termed as static binding or early binding.

Program

class A                                  //  base class

{

int a;

public:

void display()

{

cout<< “Class A “;

}

};

class B: public A                       //  derived class

{

int b;

public:

void display()

{

cout<<“Class B”;

}

};

In the above program, the display() function prototype is the same in both the base and derived classes. Therefore, static binding cannot be applied here. This program would run best at the run time with an appropriate selection of functions.

• During the run time, the language’s compiler identifies various methods by identifying signatures of those methods.
• The compiler first identifies the method signature and decides the method for a specific method call during program compilation.  
• The execution for Compile time Polymorphism is much faster but the process is not so flexible. 

Also Read: OOPS Interview Questions

Runtime or Dynamic Polymorphism

In the Dynamic Polymorphism, a call to a single overridden method is solved during a program’s runtime. Method overriding is one of the prominent examples of Runtime Polymorphism. In this process, the overriding is done through pointers and virtual functions.

Run time polymorphism is alternatively called dynamic polymorphism. This is because a method to call is decided at run time but not compiler time. Since both methods will own the same signature and could be called using any one of the class objects, the compile-time compiler doesn’t know about this; it can only be identified during runtime.

Run time polymorphism is alternatively called dynamic polymorphism. This is because a method to call is decided at run time but not compiler time. Since both methods will own the same signature and could be called using any one of the class objects, the compile-time compiler doesn’t know about this; it can only be identified during runtime.

• In Method Overriding, a single method is declared in a sub-class present in a parent class. The child class gains a method for implementation.
• During Runtime Polymorphism, the class offers the specification of its own to another inherited method. This transfer between methods is achieved without modifying the parent class object codes.

Explore Our Software Development Free Courses

Important points to note about the Polymorphism concept:

• It should have the same name, same return type, and same parameters (order, type, and length).
• It can’t override a method that is declared static or final.
• It can’t have a more restrictive access modifier.
• It may have a less restrictive access modifier.
• It should not throw a new or wider checked exception.
• It might throw fewer, narrower, or no checked exceptions.

The overriding method of polymorphism explains that it can throw any unchecked exception, irrespective of whether the overridden method states the exception.

Explore our Popular Software Engineering Courses

Types of Polymorphism in Oops

In Object-Oriented Programming (OOPS) language, there are two types of polymorphism as below:

1. Static Binding (or Compile time) Polymorphism, e.g., Method Overloading
2. Dynamic Binding (or Runtime) Polymorphism, e.g., Method overriding

Source

In-Demand Software Development Skills

1. Compile Time or Static Polymorphism

With Method Overloading, static polymorphism is achieved in Object-Oriented Programming languages that allow the programmer to implement various methods. The names they use can be the same, but their parameters are different. Certain conditions are conducive for static polymorphism as below:

•       Types of All Parameters should be different.
•       The sequence of the Parameters can be different.
•       The number of parameters of one method should differ from the other method.

In the static binding polymorphism, the matching type and number of arguments invoke the overloaded functions. 

• As all of this information is available during the compile time, the compiler selects the appropriate function. 
• The function overloading does it, and operator overloading is also termed as static binding or early binding.

Check out Java Bootcamp from upGrad

Program

class A                                  //  base class

{

int a;

public:

void display()

{

cout<< “Class A “;

}

};

class B: public A                       //  derived class

{

int b;

public:

void display()

{

cout<<“Class B”;

}

};

In the above program, the display() function prototype is the same in both the base and derived classes. Therefore, static binding cannot be applied here. This program would run best at the run time with an appropriate selection of functions.

• During the run time, the language’s compiler identifies various methods by identifying signatures of those methods.
• The compiler first identifies the method signature and decides the method for a specific method call during program compilation.  
• The execution for Compile time Polymorphism is much faster but the process is not so flexible. 

Also Read: OOPS Interview Questions

Runtime or Dynamic Polymorphism

In the Dynamic Polymorphism, a call to a single overridden method is solved during a program’s runtime. Method overriding is one of the prominent examples of Runtime Polymorphism. In this process, the overriding is done through pointers and virtual functions.

• In Method Overriding, a single method is declared in a sub-class present in a parent class. The child class gains a method for implementation.
• During Runtime Polymorphism, the class offers the specification of its own to another inherited method. This transfer between methods is achieved without modifying the parent class object codes.

Program

 #include <iostream>    

using namespace std;    

class Animal {                                          //  base class  

    public:    

    string color = “Brown”;      

};     

class Dog: public Animal                       // inheriting Animal class.  

{      

 public:    

    string color = “Green”;      

};    

int main(void) {    

     Animal d= Dog();      

    cout<<d.color;     

}    

Output:

Brown 

• In the Run time polymorphism, the object’s method is invoked at the run time instead of compile time. 
• It is made possible by method overriding, which is also coined as dynamic binding or late binding. 
• The process of dynamic polymorphism is comparatively slower but flexible than compile-time polymorphism.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Differences B/W Compile-Time and Run-Time Polymorphism 

Read our Popular Articles related to Software Development

Final Words

Polymorphism is the must learn concepts of OOPs as it offers several advantages while programming. With Polymorphism, the user can remodel the tested classes and codes. It is useful in extending the programming by itself. It also allows the user to store multiple different type variables such as double, Float, Int, or Long in a single variable to make it simpler to search and implement them. 

If you’re interested to learn more about OOPs, full-stack software development, check out upGrad & IIIT-B’s PG Diploma in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.