Polymorphism in Java

May 2, 2023

In object-oriented programming, polymorphism in java is an important concept that allows objects of different classes to be treated as if they are objects of the same class.

Java, being an object-oriented programming language, supports polymorphism, which makes it a powerful and flexible language for developing complex applications.

In this article, we will discuss what polymorphism is, how it works in Java, and some examples of its implementation.

What is Polymorphism in Java?

Polymorphism is derived from the Greek words ‘poly’ and ‘morph,’ meaning ‘many’ and ‘forms,’ respectively. In programming, polymorphism refers to the ability of objects of different classes to be treated as if they are objects of the same class. This allows a single interface to be used for different types of objects, making the code more flexible and reusable.

There are two types of polymorphism in Java:

compile-time polymorphism

runtime polymorphism.

Compile-time Polymorphism

Compile-time polymorphism, also known as static polymorphism or method overloading, occurs when the compiler determines which method to invoke based on the number and types of arguments passed to it.
The method signatures must be different for the compiler to distinguish between them. This means that the methods have the same name but different parameters.

Example: consider a class named MathUtils that contains two methods, add() and add(int, int). The add() method takes two double values as arguments and returns their sum, while the add(int, int) method takes two integer values as arguments and returns their sum. If we call the add() method with two integer values, the compiler will not be able to determine which method to invoke, and a compile-time error will occur.

Runtime Polymorphism

Runtime polymorphism, also known as dynamic polymorphism or method overriding, occurs when the method to be invoked is determined at runtime based on the actual type of the object.
This means that a method defined in a superclass can be overridden in a subclass to provide a specific implementation.

Example: consider a class hierarchy consisting of a superclass named Animal and two subclasses named Dog and Cat. The Animal class defines a method named makeSound(), which is overridden in the Dog and Cat classes to provide specific implementations for each subclass.

Polymorphism in Java Implementation

Polymorphism in Java is implemented through inheritance and method overriding. To achieve polymorphism, we create a superclass and define methods that can be overridden in the subclass.
When we create an object of the subclass, we can call the methods of the superclass on the object, and the overridden method in the subclass will be executed instead.

Advantages of Polymorphism in Java

Code Reusability

Polymorphism in Java allows us to reuse the code by creating a superclass and defining methods that can be overridden in the subclass.

This saves time and effort in developing new code and makes the code more maintainable. Instead of writing new code for each object, we can reuse the existing code and modify it as per the requirement.

Flexibility

Polymorphism makes the code more flexible by allowing us to create a single interface for different types of objects.

This means that we can use the same method to perform different operations on different objects, which makes the code more modular and easier to understand.

Extensibility:

Polymorphism in Java allows us to extend the functionality of the existing code by creating new subclasses and overriding the methods in the superclass.

This means that we can add new features to the code without modifying the existing code, which makes it easier to maintain and update the code in the future.

Easy Maintenance:

Polymorphism in Java makes the code easier to maintain by reducing the complexity of the code.

Instead of writing complex code for each object, we can use a single interface to perform the same operation on different objects.

Polymorphism Methods In Java

Methods	Description
Method Overloading:	This is when a class has multiple methods with the same name, but different parameters.
Method Overriding:	This is when a subclass provides its own implementation of a method that is already defined in its parent class.
Ad-Hoc Polymorphism:	This is when a method can take arguments of different types and behave differently depending on the type of the argument.
Interface Implementation:	Interfaces define a set of methods that a class must implement

Encapsulation in java

Inheritance in java

Multithreading in java

Example 1: The concept of Compile-time Polymorphism or method overloading.

Run

class ComplitetimePolymorph { 
  
    void operator(String str1, String str2) 
    { 
        String s = str1 + str2; 
        System.out.println("Concatenated String - " + s); 
    } 
  
    void operator(int a, int b) 
    { 
        int c = a + b; 
        System.out.println("Sum = " + c); 
    } 
} 
  
class Main { 
    public static void main(String[] args) 
    { 
        ComplitetimePolymorph obj = new ComplitetimePolymorph(); 
        obj.operator(10, 20); 
        obj.operator("Hey", "Prepster"); 
    } 
}

Output

Sum = 30

Concatenated String- HeyPrepster

Explanation:

In the given program, we have defined two methods with the same name "operator" in the ComplitetimePolymorph class. However, the parameters of both methods are different. One method takes two integer values and returns their sum, while the other method takes two string values and concatenates them.

In the main method, we create an object of the ComplitetimePolymorph class and call both the methods with different arguments. The compiler chooses the appropriate method at compile time based on the arguments passed to the method

Example 2: Polymorphism in Java through the use of inheritance and method overriding.

Run

class Animal { 
  
    void Print() 
    { 
        System.out.println("parent class"); 
    } 
} 
  
class Dog extends Animal { 
  
    void Print() 
    { 
        System.out.println("Dog barks"); 
    } 
} 
  
class Cat extends Animal { 
  
    void Print() 
    { 
        System.out.println("Cat meows"); 
    } 
} 
  
class Main { 
    public static void main(String[] args) 
    { 
  
        Animal a; 
  
        a = new Dog(); 
        a.Print(); 
  
        a = new Cat(); 
        a.Print(); 
    } 
}

Output

Dog barks
Cat meows

Explanation:

This program creates two Vectors - one empty Vector of Strings and another Vector of Integers with an initial capacity of 5.

The program then adds some elements to each of these Vectors and prints their contents using the System.out.println method.

Prime Course Trailer

Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Most Frequently Asked Questions and Answers

Question 1. What is the difference between compile-time polymorphism and runtime polymorphism?

Explanation

Compile-time polymorphism (also known as method overloading) is when multiple methods with the same name but different parameters are defined in a class. The correct method to be called is determined at compile-time based on the method signature.

Runtime polymorphism (also known as method overriding) is when a subclass provides its own implementation of a method that is already defined in its superclass. The correct method to be called is determined at runtime based on the actual object being referenced.

Question 2. What is the difference between method overloading and method overriding?

Explanation

Method overloading is when multiple methods with the same name but different parameters are defined in a class. The methods can have different return types, access modifiers, and exceptions, but must have a different method signature. Method overloading is determined at compile-time based on the method signature.

Method overriding is when a subclass provides its own implementation of a method that is already defined in its superclass. The method must have the same name, return type, and parameters as the method in the superclass. Method overriding is determined at runtime based on the actual object being referenced.

Question 3. Can a subclass override a static method in its superclass?

Explanation

Yes, a subclass can override a static method in its superclass. However, the method in the subclass is not considered to be an override, but rather a new method that hides the static method in the superclass.

Question 4. Can you give an example of how you would use Polymorphism in a real-world scenario?

Explanation

Polymorphism could be used in a real-world scenario is in a payroll system for a company. Each employee could be represented as an object, with different subclasses for different types of employees, such as full-time, part-time, and contract employees. Each subclass could have its own implementation of the calculatePay() method, using different formulas based on the employee type. The payroll system could then call the calculatePay() method on each employee object, and the correct method would be called based on the actual object being referenced, achieving Polymorphism.

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others

Polymorphism in Java

What is Polymorphism in Java?

Compile-time Polymorphism

Runtime Polymorphism

Polymorphism in Java Implementation

Advantages of Polymorphism in Java

Polymorphism Methods In Java

Example 1: The concept of Compile-time Polymorphism or method overloading.

Output

Example 2: Polymorphism in Java through the use of inheritance and method overriding.

Output

Prime Course Trailer

Related Banners

Get over 200+ course One Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription