Polymorphism in Java: Concepts, Types, Characterisitics & Examples

Javascript is one of the most popular and widely used Object-Oriented Programming languages, along with C#, PHP, Python, C++, etc. It enables users to exhibit and address real-life concepts through programming since everything is represented as an object. The features of Java as a programming language offer several avenues to simplify software development by making the codes more dynamic and easing maintenance.

In this article, we’ll explore Java as an Object Oriented Programming language and understand the concepts of inheritance, abstraction, polymorphism, and data encapsulation. We’ll also look into the types of polymorphism in Java, their advantages and disadvantages.

Overview of Object-Oriented Programming

Object-oriented programming (OOP) languages refer to those computer languages that use the concept of real-time ‘objects’ in coding. It aims at implementing worldly entities such as inheritance, polymorphism, loops, data abstraction, etc., through programming.

There are a few basic concepts of Object-Oriented Programming that programmers need to get familiar with. These conceptual terms are necessary for learning about special and unique features of OOP such as encapsulation, polymorphism, etc. 

1. Class

 A ‘class’ represents a set of properties and methods which apply to all the specified ‘objects’ within the class. The objects can be of different types such as integer, array or string, etc. A class is like a prototype defined by the user, using which different ‘objects’ can be created. 

2. Object

An object is the most fundamental unit of OOP languages, representing real data in real life. Objects bear the properties of the class(es) they are invoked in. 

3. Method

 A method is a set of statements involving different functions that are put together to perform a specific task. It returns the output after completing the instructions as defined by the user. It can also carry out tasks that deliver no output. Methods allow programmers to reuse the codes without retyping them. Java requires all the methods to belong to a class, unlike the languages like C++, C, or Python.

OOP Concepts 

There are four primary principles of Object-Oriented programming – Java exhibits all of these properties:

1. Abstraction

Data Abstraction is a property of OOP languages that showcases the necessary details while keeping the other irrelevant details of the object from visibility to the user, such as the implementation code. Only the essential and relevant details are displayed by this feature, which helps developers quickly make appropriate changes to a class’s functionality. 

2. Encapsulation

Data encapsulation refers to the wrapping of data within units. This property of OOP languages protects the encapsulated data from other functions and methods. It binds together the code and specified methods to perform operations in singular units, thus preventing them from being manipulated or accessed by outside methods. This is also known as Data Hiding.

3. Inheritance

Inheritance is another important feature of OOP languages that allows a class to inherit properties from other classes. It works upon the concept of reusability of codes, thereby reducing the need to retype class features repeatedly. The class that inherits from another class is known as the subclass, and the class being inherited is known as the superclass.

4. Polymorphism 

Polymorphism allows an object to take many forms and perform similar tasks or exhibit similar behaviors in different methods. 

Polymorphism in Java

Polymorphism allows a single task to be performed in various ways. It is a property that helps identify and differentiate between similar code entities, hence enhancing the efficiency of the OOP languages. 

In Java, polymorphism is exhibited by declaring objects as separate entities. In this manner, the same action can be performed in multiple ways. Polymorphism is activated along with inheritance, enabling the objects to carry out different tasks using the inherited properties of different classes. Differences in the designation of methods or objects distinguish two entities.

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

Characteristics of Polymorphism

1. Coercion

The implicit conversion of data types to prevent type errors during compilation time is coercion. It does not include explicit data type conversions but follows only the hierarchy of conversion that Java allows. For example, if an operand is afloat and the operator is an integer, the resultant will be afloat.

2. Polymorphic parameters/ variables

An object or variable that can hold values of various types during execution time is known as a polymorphic variable or parameter. It dictates that while declaring a class, the same variable names can hold different data types, and the same method names can hold different parameters and return types.

3. Internal Operator Overloading

Operator overloading uses an operator symbol as required by the user. Java supports Internal Operator Overloading. It is also an example of static polymorphism.

Types of Polymorphism in Java

In Java, polymorphism can be invoked using:

1. Method Overloading

Method overloading is the process of creating multiple objects or methods bearing the same name and belonging to the same class. It functions within a class. 

2. Method Overriding

 Method overriding is how a subclass constitutes the same methods as declared in the superclass. It functions across classes. If the subclass contains the same methods already present in the superclass, then the function in the subclass is overridden.

Subtype Polymorphism in Java

Subtype polymorphism depends upon Upcasting and Late Binding. 

  • Upcasting is a process by which an object or Method can promote a data type (float, integer, etc.) from a subtype to a supertype by moving it up the inheritance hierarchy. 
  • Late binding is used to call methods which are non-final instances.

No operator is involved in this because the subtype itself is a member of the supertype. For example, if a class is named colors, its subtypes can be red, blue, orange, green, etc. Subtype polymorphism includes the subtypes to exhibit the properties of the supertype. However, the access to individual properties of each subtype is lost.

Runtime Polymorphism in Java

In Java, runtime polymorphism is also known as the Dynamic Method Dispatch or Dynamic Binding. It is achieved through Method overriding – calling an overridden method to provide dynamically resolved at runtime. It can be achieved through functions and not objects.

Here’s an example of runtime polymorphism in Java:

class Car{  

  void run(){System.out.println(“driving”);}  


class Volkswagen extends Car{  

  void run(){System.out.println(“Driving safely with 90km”);}  


  public static void main(String args[]){  

    Car c = new Volkswagen();//upcasting;  



Driving safely with 90km

Compile Time Polymorphism In Java

Compile-time polymorphism is achieved by method overloading. It is the process in which the call for an overloaded method is carried out and resolved during compile time. It is also known as static polymorphism. Java is flexible enough to allow the user to use methods or objects having the same names as long as its declarations and signature properties remain different.

Here’s an example of compile-time polymorphism in Java:

class SimpleCalc


    int add(int x, int y)


         return x+y;


    int add(int x, int y, int z)  


         return x+y+z;



public class Demo


   public static void main(String args[])


SimpleCalc obj = new SimpleCalc();

       System.out.println(obj.add(20, 30));

       System.out.println(obj.add(40, 30, 20));






Importance of Polymorphism

Polymorphism enables the writing of methods that can constitute different types of entities bearing the same name. Polymorphism is essential in Java because of its various usage benefits and the scope it provides for making the code dynamic:

  1. It allows for the reusability of codes – the same codes need not be written several times. 
  2. It allows one variable to exhibit multiple behaviors – having the same name but different properties can open up scope for maintaining consistency in codes.
  3. Reduction of bulk codes – it helps in debugging while also shortening the compile-time, saving the user’s memory, energy, and time.

Possible Problems in Implementing Polymorphism

Polymorphism can be confusing to use and implement. It reduces the readability of codes, hence posing threats of multiple bugs and errors. It also creates issues with performing functions as required.

There is one classic problem to look out for: The Fragile Base Class problem. It refers to improper assembling and coding of an inherited class that results in methods showing unpredictable outcomes. 


The fragile nature of inheritance can lead to dysfunctional and broken codes despite all other criteria remaining fulfilled. This basic architectural issue is regarded as the Fragile Base Class problem. Learn more about how Java exhibits OOP concepts by joining upGrad’s Executive PG Programme in Software Development – Specialisation in Full Stack Development. Get mentored by industry experts and build practical knowledge by engaging in hands-on, collaborative projects with peers.

Book your seat today!

What is static and dynamic binding?

Objects that are determined at the time of compilation are known as static binding. On the other hand, dynamic binding types of objects are determined at the run-time. The former is used during method overloading and the latter during method overriding.

What are the two fundamental differences between method overriding and method overloading?

In Java, method overriding does not override static, private and final methods, whereas method overloading does overload static, private and final methods in Java. Also, overriding subjects methods to dynamic binding and, on the other hand, overloaded methods go through static binding.

What are the differences between polymorphism and inheritance in Java?

In Java, there are several points of difference between Polymorphism and Inheritance:

1. Inheritance is a representation of the real-world parent-child relationship in coding. But polymorphism is a catalyst that uses this relation to make the program more dynamic.
2. Inheritance allows reusability of codes from the child class by inheriting the same from the parent class. Polymorphism, in contrast, allows the child class to redefine its existing behaviour again inside the parent class.

Want to share this article?

Prepare for a Career of the Future

Leave a comment

Your email address will not be published. Required fields are marked *

Our Popular Software Engineering Courses

Get Free Consultation

Leave a comment

Your email address will not be published. Required fields are marked *

Let’s do it!
No, thanks.