Hero Vired Logo


Vired Library

Special scholarships for women candidates all through March.

Apply Now

or Chat with us on

Polymorphism in Java - Types, Advantages, Examples

Polymorphism is referred to the capacity of an object to adopt various forms. However, polymorphism in Java describes a class’s capability to offer several method deployments based on the kind of object it receives as input. 


In simple terms, polymorphism in Java enables us to execute the same task in a range of ways. Now the Polymorphic Java objects are ones that are capable of passing multiple IS-A tests. Since the IS-A tests for both the class Object and their own type passed, every single Java object is polymorphic. 


In this article, you’ll learn not only ‘what is polymorphism in Java’ but also its types and their examples. Moreover, the article covers insights into the benefits and drawbacks of Java polymorphism. So, let’s delve in. 


Table of Content

What is Java Polymorphism?

Polymorphism in Java refers to a job that executes a single operation in multiple unique manners. Languages that fail to support or facilitate polymorphism in Java are called ‘object-based languages’ rather than ‘object-oriented languages.’ Consider the language ‘Ada’ as an example. 

The fact that Java supports polymorphism means it is an object-oriented language. Inheritance, or relationship between various classes, results in Java polymorphism. 

Java has a powerful inheritance capability. Java inheritance enables a class to inherit the characteristics and features of another class. Polymorphism in Java enables us to exploit these inherited features for various purposes. This enables us to carry out the same action in a variety of ways.


Characteristics of Polymorphism in Java

The two main characteristics of polymorphism in Java are Method Overriding and Method Overloading. Besides that, the other characteristics include: 

  • Polymorphic variables
  • Internal operator overloading
  • Coercion


  • Coercion:

It focuses on indirectly transforming a single sort of thing into a brand-new entity that is an entirely distinct type. Additionally, this is carried out automatically to avoid typing mistakes in the code. 

  • Internal Operator Overloading:

According to the given input context or the kind of operands, an overloading symbol or operator will behave in multiple ways. It belongs to the static polymorphism property set. 

  • Polymorphic Variables: 

In Java, polymorphic variables are referred to as object or instance variables. That’s because any class object variables can have an IS-A relationship with their subclasses and classes. 


Types of Java Polymorphism

Now that we have understood what is polymorphism in java, let’s look at the type of it. Polymorphism in Java consists of two major types:

  • Runtime Polymorphism (dynamic)
  • Compile-Time Polymorphism (static)


1. Compile-Time Polymorphism

Compile Time Polymorphism in Java is also popularly called Static Polymorphism. It is the compile time when the method resolves the call. One can accomplish or achieve compile-time via Method Overloading. Operator Overloading is another method for achieving this kind of polymorphism. However, Java doesn’t support overloading.


2. Runtime Polymorphism

Runtime polymorphism in Java is also referred to by the terms’ dynamic method dispatch’ and ‘dynamic binding.’ This Java polymorphism method resolves the call/request to an overridden method programmatically during runtime as opposed to compile-time. One can achieve or accomplish runtime polymorphism via Method Overriding. 


3. Method Overloading

The term “method overloading” refers to the situation in which a class contains many methods holding the same name but distinct return types, parameter types, numbers and order. Java allows users to give different functions the same name as long as Java can tell them apart based on the type and quantity of parameters. 


Already excited to get started with Java polymorphism? Upgrade your skills and knowledge with a full-stack development course. Here is a blog on ‘What is full-stack development” to help you kickstart this journey. 


4. Method Overriding

Whenever a child class or subclass declares a method that pre-exists in the parent class, it is called method overriding.


How Method Overriding is Used to Implement Polymorphism in Java

The process of overriding a method in Java polymorphism occurs when a child or subclass has a method with the same return type, parameters, and name as the superclass or parent. However, in that case, the function in the superclass is replaced. 


In simple terms, a function in the base class is considered overridden when the subclass gives its definition to one of the pre-existing methods in the superclass.


Take note that only functions—not data members—can implement runtime polymorphism. One can achieve or accomplish Method Overriding by leveraging a superclass reference variable. The object that the reference variable is referring to determines which method has to be called. This process is referred to as Upcasting. 


For example,

class A{} 
class B extends A{}  
A a=new B(); //upcasting

Example of Method Overriding in Polymorphic

Now that we have understood what is polymorphism in java, let’s look at some of the examples of polymorphism in java.

class Automobile{  
  //defining a method  
  void run(){System.out.println("Car is sputtering");}  
//Creating a child class  
class Car2 extends Autombile{  
  //defining the exact method as in the parent class  
  void run(){System.out.println("car is facing some issue");}  
  public static void main(String args[]){  
  Car2 obj = new Car2();//creating object  
  obj.run();//calling method  

Output: Car is facing some issue

Interfaces and Polymorphism

Polymorphism in Java is formalized through interfaces. Interfaces provide logical definitions of Java polymorphism that are independent of implementation. If two components implement the exact same interfaces, they are polymorphic with regard to an array of behaviors. 

Polymorphism in Java has long been touted as an important advantage of object orientation. Despite this, there had been no means of implementing it, confirming it, or even just conveying it without interfaces, except informally or in terms of a particular language. 

Formalizing interfaces removes the element of surprise and enables us to state what Java polymorphism has been attempting to accomplish clearly. Interfaces may be tested, verified, and are accurate.

Real-Life Examples of Java Polymorphism

This section will help you understand Java polymorphism better with some real-life examples. A person may be in multiple relationships with multiple individuals. A woman can simultaneously play the roles of mother, daughter, sister, and friend, which means she exhibits different behaviors in various contexts.


There are numerous organs in a person’s body. Every organ has a specific task, such as the heart’s role in blood circulation, the lungs’ role in respiration, the brain’s role in thinking, and the kidneys’ role in urination. So, based on the body organ, our typical method function behaves in distinct ways. Also read our guide on Full Stack Salaries in India.


Advantages of Polymorphism in Java:

Polymorphism in Java comes with the following advantages: 

  • Allows objects of various classes to be handled as though they were of a single class, resulting in more code recycling.
  • Lowers the quantity of code required to be produced and preserved, increasing the code’s comprehensibility and upkeep.
  • Allows for dynamic binding, allowing the appropriate method to be invoked at runtime depending on the object’s real class.
  • Allows for the treatment of objects as a single type, which makes it simpler to create a universal code that is capable of handling objects of various types.

Disadvantages of Polymorphism in Java:

Here are the two downsides of Polymorphism in Java: 

  • Understanding an object’s behavior may become more challenging, particularly if the code is complicated.
  • Performance problems could result from this since polymorphic behavior might call for more calculations to be done at runtime.

What is the difference between Compile-time Polymorphism and Runtime Polymorphism?

Here is a table demonstrating the difference between Runtime Polymorphism and Compile-Time Polymorphism: 

Runtime Polymorphism Compile-Time Polymorphism
The compiler doesn’t resolve the call The compiler resolves the call
It is also referred to as overriding, late binding, and dynamic binding It is also referred to as overloading, early binding and static binding
Virtual pointers and functions help achieve runtime polymorphism Operator overloading and function overloading helps achieve compile-time polymorphism
It involves inheritance It doesn’t involve inheritance


In this guide, we have understood what is polymorphism in java. We believe you now have a rudimentary understanding of polymorphism in Java, how we utilize it, and some examples. Thus, this concludes the blog post on Java polymorphism. Additionally, look at the Full stack development courses on Hero Vired to learn more about programming and related ideas. 


However, if you’re still confused and having second thoughts about whether to pursue full-stack development or not, we have something for you.


Polymorphism in Java is considered among the key components of object-oriented programming. We are able to carry out a single task in various ways because of polymorphism. In other words, polymorphism enables the definition of a single interface with various implementations.
Polymorphism in Java consists of the following types:
  • Runtime polymorphism (subtype)
  • Overloading polymorphism (overloading)
  • Casting polymorphism (coercion)
  • Compile-time polymorphism (Ad hoc)
Runtime polymorphism can be accomplished using Method Overriding. Additionally, it must be emphasized that data members cannot be used to accomplish runtime polymorphism; only function parameters can.
Here is an example of Polymorphism in Java: Animal
class Animal{
void eat(){System .out.println("chewing...");}
class Dog extends Animal{
void eat(){System.out.println("chewing meat...");}
class Cat extends Animal{
void eat(){System.out.println("chewing fish...");}

Blogs from other domain

Carefully gathered content to add value to and expand your knowledge horizons

Hero Vired logo
Hero Vired is a premium LearnTech company offering industry-relevant programs in partnership with world-class institutions to create the change-makers of tomorrow. Part of the rich legacy of the Hero Group, we aim to transform the skilling landscape in India by creating programs delivered by leading industry practitioners that help professionals and students enhance their skills and employability.
Privacy Policy And Terms Of Use
©2023 Hero Vired. All Rights Reserved.
  • *
    These figures are indicative in nature and subject to inter alia a learner's strict adherence to the terms and conditions of the program. The figures mentioned here shall not constitute any warranty or representation in any manner whatsoever.