In this post, we feature a comprehensive Polymorphism Java Example.
1. Introduction
In word Polymorphism, the word Poly stands for ‘many’ and the word morph stands for ‘forms’. Polymorphism is the ability of an object to take on many forms. Polymorphism is the capability of an action or method to do different things based on the object that it is an action upon. Polymorphism is one of the Object-Oriented Programming principles used along with Encapsulation and Inheritance in Programming languages like C++, Java, and Python. It provides flexibility to the programmers to interact with different objects by using the same message.
You can also check this tutorial in the following video:
2. Types of Polymorphism
In Java, Polymorphism can be achieved in two ways using Method Overloading and Method Overriding. Method Overloading is also called as Compile time Polymorphism or early binding, whereas Method Overriding is also called as Runtime Polymorphism or late binding. Let us now understand in detail both of them.
2.1 Method Overloading
Two methods are said to overloaded if they have the same method name and different parameters i.e either two methods should have a different number of parameters or the data types of the parameters of two methods must be different.
Let us understand this with a coding snippet below:
// program to show method overloading in java
package com.javacodegeeks.snippets.core;
class Example1
{
public static String add(String s1, String s2) //method to perform String concatenation
{
return s1+s2;
}
public static int add(int a,int b) //method to perform int addition
{
return a+b;
}
public static void main(String[] args) {
System.out.println(add(10,30)); //calls add function with int params
System.out.println(add("Rajesh","Kumar")); //calls add function with String params
}
}
Output
40 RajeshKumar
In this example, when we pass String parameters to the method add, add() method at Line 6 is getting executed. This method returns the String after concatenation of both Strings s1 and s2. But when we passed integer values to the add method, add() method at Line 11 is getting executed and it returns the addition of two values. Here we used the same method name add, we are able to interact with two functionalities based on the parameters which are passed.
The compiler is able to recognize these method calls and therefore it is also called Compile time Polymorphism.
2.2 Method Overriding
In Method Overriding, during Inheritance, a child class provides its own implementation to the Parent’s method, thereby overriding the implementation of the parent. Two methods are said to be overridden only if they have the same Signature, that is, the same name and same parameters.
In this context, the Parent’s method is called an Overridden method and the Child’s method is called an Overriding method.
Let us understand what does below coding snippet contains :
Shapeclass has two methods,drawShape()anderaseShape().- Classes
Circle,SquareandTriangleextendShapeand override its two methods, each one in a different way. RandomShapeGeneratorclass has a method,Shape next()that randomly creates one of the above classes,Circle,SquareandTriangle.- We create a new
RandomShapeGeneratorinstance and a newShapearray. - We fill the
Shapearray, by creating random shapes, using thenext()method ofRandomShapeGenerator. - Then we call
drawShape()method, so each time the method of the object created randomly is called.
Let us take a look at the code snippet that follows:
|
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
package com.javacodegeeks.snippets.core;import java.util.Random;class Shape { void drawShape() { } void eraseShape() { }}class Circle extends Shape { @Override void drawShape() { System.out.println("Circle.draw()"); } @Override void eraseShape() { System.out.println("Circle.erase()"); }}class Square extends Shape { @Override void drawShape() { System.out.println("Square.draw()"); } @Override void eraseShape() { System.out.println("Square.erase()"); }}class Triangle extends Shape { @Override void drawShape() { System.out.println("Triangle.draw()"); } @Override void eraseShape() { System.out.println("Triangle.erase()"); }}// A "factory" that randomly creates shapes:class RandomShapeGenerator { private Random rand = new Random(); //Choose randomly a circle, a squere or a triangle public Shape next() { switch (rand.nextInt(3)) {default:case 0: return new Circle();case 1: return new Square();case 2: return new Triangle(); } }}public class Polymorphism { private static RandomShapeGenerator gen = new RandomShapeGenerator(); public static void main(String[] args) { //This is an array of references of the superclass Shape Shape[] s = new Shape[9]; // Fill up the array with random shapes shapes: for (int i = 0; i < s.length; i++) {s[i] = gen.next(); } //s[x].drawShape will call the specific drawShape function of whichever //shape is s[x] and not the drawShape function of class Shape //That's polymorphism. for (int i = 0; i < s.length; i++) {s[i].drawShape(); } }} |
Output
Square.draw()
Square.draw()
Circle.draw()
Triangle.draw()
Triangle.draw()
Square.draw()
Circle.draw()
Circle.draw()
Square.draw()
3. Benefits of Polymorphism
1. Method overloading allows methods that perform similar or closely related functions to be accessed through a common name. For example, a program performs operations on an array of numbers which can be int, float, or double type. Method overloading allows you to define three methods with the same name and different types of parameters to handle the array operations.
2. Method overloading can be implemented on constructors allowing different ways to initialize objects of a class. This enables you to define multiple constructors for handling different types of initializations.
3. Method overriding allows a subclass to use all the general definitions that a superclass provides and adds specialized definitions through overridden methods.
4. Method overriding works together with inheritance to enable code-reuse of existing classes without the need for re-compilation.
4. Polymorphism Java Example
In this post, we have started with Polymorphism definition, how it can be achieved in Java using Method Overloading and Method Overriding. Then we clearly understood how we can implement Method Overloading and Method Overriding programmatically. Finally, we ended our topic by understanding the benefits of using Polymorphism.
5. More articles
- Java Tutorial for Beginners
- Best Way to Learn Java Programming Online
- Java Constructor Example
- Java Collections Tutorial
- Hashmap Java Example
6. Download the Source Code
This is an example of Polymorphism in java.
You can download the full source code of this example here: Polymorphism Java Example
Last updated on May 22nd, 2021
