Polymorphism In Java

Polymorphism In Java: Welcome to another brand new post on the Core Java tutorial Series; in our last post, we discussed the importance and how to use the method overriding & method hiding in Java. In this post, we are going to discuss another important feature of the Java OOPS concept, which is polymorphism.

Polymorphism allows us to perform a single action but in different ways. Polymorphism comes from a Greek language and means “Many Forms.” In simple words, we can say that this is the ability of Java programming language by which “we can create functions or reference variables which behave differently in a different programming context.”

What Is Polymorphism?

The word Polymorphism comes from two Greek words – poly and morphs. “Poly” means many, and “Morphs” means shapes or forms. So, polymorphism means having many forms. In Object-Oriented Programming, polymorphism is an important feature that allows objects to take on different forms or behaviors.

In Java, polymorphism means that an object can act in different ways or have different forms depending on how it is used. This is made possible by using two techniques: inheritance and interfaces.

Inheritance allows a subclass to inherit the properties and methods of its superclass while also allowing the subclass to override or extend the behavior of those methods. This allows the subclass to behave differently from its superclass while still being treated as an instance of the superclass.

Interfaces, on the other hand, allow multiple classes to implement a common set of methods, which can be used interchangeably. This allows for greater flexibility and reusability in code design, as any class that implements an interface can be used instead of any other class that implements the same interface.

I hope you have got an idea about these important topics. Now let’s move further and understand the different types of polymorphism in Java with examples.

Types of Polymorphism in Java

Java programming language supports two types of polymorphism, and that is:

• Static Polymorphism (Compile-time)
• Dynamic Polymorphism (Runtime)

Compile Time Or Static Polymorphism

In this type of polymorphism, the method call is resolved at compile-time based on the number, types, and order of the arguments passed to the method. Method overloading is an example of compile-time polymorphism.

Method Overloading: This allows us to have more than one method having the same name but different parameter lists where the sequence and data types of parameters are different. For more information, you can refer to our Method Overloading post.

Static Polymorphism Example: Method overloading is one of the ways Java supports static polymorphism.

package com.SoftwareTestingo.JavaBasics;
class PolymorphismEx
{
   public void displayString(String str)
   {
      System.out.println("Single Parameterized Display Method Executed");
   }
   public void displayString(String str, String str1) 
   {
      System.out.println("Double Parameterized Display Method Got Executed");
      
   }
}
public class Static_Polymorphism 
{
   public static void main(String[] args) 
   {
      ParentClassEx obj=new ParentClassEx();
      obj.displayString("Welcome"); // Will Call Single Parameterized Method
      obj.displayString("WELCOME", "USER");// Will Call Double Parameterized Method
   }
}

Output:

Single Parameterized Display Method Executed
Double Parameterized Display Method Got Executed

Dynamic or Runtime Polymorphism

In this type of polymorphism, the method call is resolved at runtime based on the actual type of the object on which the method is called. An example of runtime polymorphism is method overriding, where a subclass can implement a method defined in its superclass. We have a full post where we have discussed Method Overriding in Java.

package com.SoftwareTestingo.JavaBasics;
class Vehicle
{
   public void speed()
   {
      System.out.println("Speed Method of Vehicle Class Executed");
   }
}
class Bike extends Vehicle
{
   public void speed()
   {
      System.out.println("Speed Method Of Bike Class Executed");
   }
}
public class MethodDispatch extends Vehicle
{
   public static void main(String[] args) 
   {
      Vehicle obj=new Vehicle();
      Vehicle obj1=new Bike();
      
      obj.speed();
      obj1.speed();
   }
}

Output:

Speed Method of Vehicle Class Executed
Speed Method Of Bike Class Executed

When a user wants to call an overridden method by using a parent class reference, then the object type determines which method will execute determined at run time. Since both the classes have the same method at that time, which method is going to call is determined at runtime by JVM.

Ref – article