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 will discuss another important feature of the Java OOPS concept: 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 an object can act differently or have different forms depending on its use. 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, however, 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)
Polymorphism In Java With Explanation

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 multiple methods with the same name but different parameter lists where the sequence and data types of parameters are different. For more information, 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 discuss 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 classes have the same method at that time, JVM determines which method will be called at runtime.

Ref – article

Avatar for Softwaretestingo Editorial Board

I love open-source technologies and am very passionate about software development. I like to share my knowledge with others, especially on technology that's why I have given all the examples as simple as possible to understand for beginners. All the code posted on my blog is developed, compiled, and tested in my development environment. If you find any mistakes or bugs, Please drop an email to softwaretestingo.com@gmail.com, or You can join me on Linkedin.

Leave a Comment