JavaPolymorphism in Java

Polymorphism in Java

A key concept of object-oriented programming (OOP) is polymorphism, which enables developers to write code that can work differently based on the context, makes your code more flexible, and extensible.

In this Java programming tutorial, you will learn about polymorphism, its benefits and downsides, and the different types of polymorphism in Java with sample programs wherever appropriate.

Looking to learn Java in a class or online course? We have a list of the Top Online Courses to Learn Java to help get you started.

What is Polymorphism in Java?

The power of object-oriented programming lies in its simplicity. The concept of polymorphism is one of the cornerstones of object-oriented programming. In fact, it is a key element of what makes OOP so powerful.

Polymorphism allows programmers to reuse code — you can create a general-purpose method that can handle multiple types of data, and then have different implementations of this method that can work differently based on the context. This saves developers from having to rewrite the same code over and over again to accommodate different types or configurations.

While the meaning of the word “poly” is “many”, the word “morphos” means “forms”. Hence, the word polymorphism implies the existence of the same thing in differing forms. It is a way of implementing abstraction; it is the ability to use a single interface to handle many different types of data. You can take advantage of polymorphism to reuse code and make your code flexible.

Polymorphism, in the context of Java, means that the same method name can be implemented in different ways, depending on the data type. A simple implementation of polymorphism can be an abstract class called Shape that implements an area() method, which returns the area of any shape whose type is derived from Shape (i.e., Square, Circle, and Triangle, etc).

Benefits and Downsides of Polymorphism in Java

Polymorphism is the ability to override a method or class and use it in more than one context. It allows us to write flexible code that can be extended and reused in many different situations. Polymorphism can allow different classes to share common functionality while still maintaining their own individual behavior.

However, there are some downsides as well: since polymorphism relies on inheritance, it requires inheritance, which in itself is not favored for application performance because you might have to create several objects in your application to resolve the calls to the methods spread across different classes, which can be cumbersome.

Additionally, if you are not careful with your design decisions, polymorphism can lead to complicated situations where types become tangled and difficult to understand or maintain in the long run.

Read: Best Tools for Remote Developers

What are the Different Types of Polymorphism in Java?

Polymorphism refers to the ability to use objects of a given class differently depending on the object’s runtime type. Polymorphism can broadly be categorized into two types: Dynamic Polymorphism or Late Binding and Static Polymorphism – or, Early Binding.

Static polymorphism is a form of polymorphism where the type of an object is known at compile time, (i.e., the compiler can figure out which method to call at compile time without needing to know the actual runtime type of the object).

Static polymorphism is known as early binding because it happens at compile time and not at runtime like dynamic polymorphism. Static or compile time polymorphism (also known as function overloading) is a type of polymorphism that allows you to create methods that have identical names but differ in their signatures.

For example, you may create an add function that can be used to add two numbers together, or three numbers together, or four numbers together. Another example of static polymorphism – or compile-time polymorphism – is operator overloading, which allows programmers to define how operators such as +, , *, and / work with different data types.

Hence, you can overload the + operator in order to concatenate two strings or add two integers. You may write a function that can print out the details of any object, without knowing the specific type of the object ahead of time.

The following code example illustrates how you can implement function overloading or method overloading in Java:

public class HelloWorld{
     public static void main(String []args){
        System.out.println(MathHelper.Add(5, 9));
        System.out.println("\n" + MathHelper.Add(9.8, 5.7));
     }
}
class MathHelper {
    static int Add(int x, int y)
    {
        return x + y;
    }
    static double Add(double x, double y)
    {
        return x + y;
    }
}

Dynamic polymorphism is a particular type of polymorphism where the object type is not known until runtime, thus making it dynamic. Dynamic polymorphism is also known as late binding since the runtime can determine the object type only when the program is in execution, i.e., at runtime.

Dynamic – or runtime polymorphism – is a type of polymorphism in which the call to a function is resolved only at runtime. It allows you to write code that is flexible and can work with objects of different types without knowing the specific type of object in advance.

The following code example illustrates how you can implement late binding in Java:

abstract class Base {
    public void display() {
    System.out.println("This is the display method of the base class.");
    }
}
public class Derived extends Base {
@Override
    public void display() {
    System.out.println("This is the display method of the derived class");
    }
    public static void main(String args[]) {
        Base obj = new Derived();
        obj.display();
    }
}

When you execute the preceding code listing, the following text message will be displayed at the console window:

Java polymorphism examples

Final Thoughts on Polymorphism in Java

Polymorphism is an integral part of object-oriented programming in general and Java, so it is essential to comprehend how polymorphism works to use it effectively. Polymorphism can help you write code that is simple, robust, flexible, and easy to maintain. In this programming tutorial, we have examined the concepts related to polymorphism, its benefits and downsides and how it can be implemented in Java.

Read more Java programming tutorials and software development tips.

Latest Posts

Related Stories