Polymorphism in Java with Examples in 2024- Nice Studying

What’s Polymorphism in Java?

Polymorphism in Java is the duty that performs a single motion in several methods.

So, languages that don’t help polymorphism will not be ‘Object-Oriented Languages’, however ‘Object-Primarily based Languages’. Ada, as an example, is one such language. Since Java helps polymorphism, it’s an Object-Oriented Language.

Polymorphism happens when there may be inheritance, i.e., many lessons are associated.

Inheritance is a robust characteristic in Java. Java Inheritance lets one class purchase the properties and attributes of one other class. Polymorphism in Java permits us to make use of these inherited properties to carry out completely different duties. Thus, permitting us to attain the identical motion in many various methods.

What’s Polymorphism?

The derivation of the phrase Polymorphism is from two completely different Greek words- poly and morphs. “Poly” means quite a few, and “Morphs” means kinds. So, polymorphism means innumerable kinds. Polymorphism, due to this fact, is without doubt one of the most important options of Object-Oriented Programming.

Actual-Life Examples of Polymorphism

A person can have completely different relationships with completely different individuals. A lady is usually a mom, a daughter, a sister, and a pal, all on the similar time, i.e. she performs different behaviors in several conditions.

The human physique has completely different organs. Each organ has a special perform to carry out; the guts is chargeable for blood movement, the lungs for respiratory, the mind for cognitive exercise, and the kidneys for excretion. So we now have a typical methodology perform that performs in another way relying upon the organ of the physique. 

Polymorphism in Java Instance

A superclass named “Shapes” has a way referred to as “space()”. Subclasses of “Shapes” might be “Triangle”, “circle”, “Rectangle”, and many others. Every subclass has its method of calculating space. Utilizing Inheritance and Polymorphism means, the subclasses can use the “space()” methodology to search out the world’s system for that form.

class Shapes 
  public void space() 
    System.out.println("The system for space of ");
  

class Triangle extends Shapes 
  public void space() 
    System.out.println("Triangle is ½ * base * peak ");
  

class Circle extends Shapes 
  public void space() 
    System.out.println("Circle is 3.14 * radius * radius ");
  

class Primary 
  public static void most important(String[] args) 
    Shapes myShape = new Shapes();  // Create a Shapes object
    Shapes myTriangle = new Triangle();  // Create a Triangle object
    Shapes myCircle = new Circle();  // Create a Circle object
    myShape.space();
    myTriangle.space();
    myShape.space();
    myCircle.space();
  

Output:

The system for the world of the Triangle is ½ * base * peak
The system for the world of the Circle is 3.14 * radius * radius

class Form 
    public void draw() 
        System.out.println("Drawing a form");
    


class Circle extends Form 
    @Override
    public void draw() 
        System.out.println("Drawing a circle");
    


class Sq. extends Form 
    @Override
    public void draw() 
        System.out.println("Drawing a sq.");
    


class Primary 
    public static void most important(String[] args) 
        Form s1 = new Circle();
        Form s2 = new Sq.();

        s1.draw(); // Output: "Drawing a circle"
        s2.draw(); // Output: "Drawing a sq."
    

On this instance, we now have a base class Form with a single methodology draw() that prints “Drawing a form” to the console. We then create two subclasses, Circle and Sq., that override the draw() methodology to print “Drawing a circle” and “Drawing a sq.” respectively.

Within the most important methodology, we create two situations of the Form class, s1 and s2, which are literally situations of the Circle and Sq. subclasses. After we name the draw() methodology on these objects, the proper implementation known as based mostly on the precise sort of the article, that is run-time polymorphism. This system will output: “Drawing a circle” and “Drawing a sq.”

On this instance, the draw() methodology is overridden within the subclasses, and this enables for this system to find out which methodology to make use of at runtime. This is called runtime polymorphism or dynamic polymorphism, As a result of at runtime the JVM determines the precise sort of the article and calls the corresponding methodology.

Additionally Learn: OOPs ideas in Java

Kinds of Polymorphism

You may carry out Polymorphism in Java by way of two completely different strategies:

1. Technique Overloading
2. Technique Overriding

What’s Technique Overloading in Java?

Technique overloading is the method that may create a number of strategies of the identical identify in the identical class, and all of the strategies work in several methods. Technique overloading happens when there may be a couple of methodology of the identical identify within the class.

Instance of Technique Overloading in Java

class Shapes 
  public void space() 
    System.out.println("Discover space ");
  
public void space(int r) 
    System.out.println("Circle space = "+3.14*r*r);
  

public void space(double b, double h) 
    System.out.println("Triangle space="+0.5*b*h);
  
public void space(int l, int b) 
    System.out.println("Rectangle space="+l*b);
  




class Primary 
  public static void most important(String[] args) 
    Shapes myShape = new Shapes();  // Create a Shapes object
    
    myShape.space();
    myShape.space(5);
    myShape.space(6.0,1.2);
    myShape.space(6,2);
    
  

Output:

Discover space
Circle space = 78.5
Triangle space=3.60
Rectangle space=12

What’s Technique Overriding in Java?

Technique overriding is the method when the subclass or a baby class has the identical methodology as declared within the mother or father class.

Instance of Technique Overriding in Java

class Car  
  //defining a way  
  void run()System.out.println("Car is transferring");  
  
//Creating a baby class  
class Car2 extends Car  
  //defining the identical methodology as within the mother or father class  
  void run()System.out.println("automotive is operating safely");  
  
  public static void most important(String args[])  
  Car2 obj = new Car2();//creating object  
  obj.run();//calling methodology  
    
  

Output:

Automobile is operating safely

Additionally, Polymorphism in Java might be categorized into two varieties, i.e:

1. Static/Compile-Time Polymorphism
2. Dynamic/Runtime Polymorphism

What’s Compile-Time Polymorphism in Java?

Compile Time Polymorphism In Java is also called Static Polymorphism. Moreover, the decision to the tactic is resolved at compile-time. Compile-Time polymorphism is achieved by means of Technique Overloading. Such a polymorphism will also be achieved by means of Operator Overloading. Nonetheless, Java doesn’t help Operator Overloading.

Technique Overloading is when a category has a number of strategies with the identical identify, however the quantity, varieties, and order of parameters and the return sort of the strategies are completely different. Java permits the consumer freedom to make use of the identical identify for varied features so long as it may well distinguish between them by the kind and variety of parameters. Take a look at among the essential questions on run time polymorphism in java interview questions.

Instance of Compile-Time Polymorphism in Java

We are going to do addition in Java and perceive the idea of compile time polymorphism utilizing subtract() 

package deal staticPolymorphism; 
public class Addition 
 
void sum(int a, int b) 
 
int c = a+b; 
System.out.println(“ Addition of two numbers :” +c);  
void sum(int a, int b, int e) 
 
int c = a+b+e; 
System.out.println(“ Addition of three numbers :” +c);  
public static void most important(String[] args) 
 
Addition obj = new Addition(); 
obj.sum ( 30,90); 
obj.sum(45, 80, 22); 
 

The output of this system will probably be: 

Sum of two numbers: 120 

Sum of three numbers: 147 

On this program, the sum() methodology overloads with two varieties by way of completely different parameters. 

That is the essential idea of compile-time polymorphism in java the place we will carry out varied operations through the use of a number of strategies having the identical identify.

What’s Runtime Polymorphism in Java?

Runtime polymorphism in Java can be popularly often known as Dynamic Binding or Dynamic Technique Dispatch. On this course of, the decision to an overridden methodology is resolved dynamically at runtime moderately than at compile-time. You may obtain Runtime polymorphism by way of Technique Overriding.

Technique Overriding is finished when a baby or a subclass has a way with the identical identify, parameters, and return sort because the mother or father or the superclass; then that perform overrides the perform within the superclass. In less complicated phrases, if the subclass gives its definition to a way already current within the superclass; then that perform within the base class is alleged to be overridden.

Additionally, it must be famous that runtime polymorphism can solely be achieved by means of features and never information members. 

Overriding is finished through the use of a reference variable of the superclass. The tactic to be referred to as is decided based mostly on the article which is being referred to by the reference variable. That is also called Upcasting.

Upcasting takes place when the Mum or dad class’s reference variable refers back to the object of the kid class. For instance:

class A 
class B extends A  
A a=new B(); //upcasting

Examples of Runtime Polymorphism in Java

Instance 1:

On this instance, we’re creating one superclass Animal and three subclasses, Herbivores, Carnivores, and Omnivores. Subclasses lengthen the superclass and override its eat() methodology. We are going to name the eat() methodology by the reference variable of Mum or dad class, i.e. Animal class. Because it refers back to the base class object and the bottom class methodology overrides the superclass methodology; the bottom class methodology is invoked at runtime. As Java Digital Machine or the JVM and never the compiler determines methodology invocation, it’s, due to this fact, runtime polymorphism.

class Animal  
  void eat()
System.out.println("Animals Eat");
  
  
class herbivores extends Animal  
  void eat()
System.out.println("Herbivores Eat Vegetation");
 
  
class omnivores extends Animal  
  void eat()
System.out.println("Omnivores Eat Vegetation and meat");
 
  
class carnivores extends Animal  
  void eat()
System.out.println("Carnivores Eat meat");
 
  
class most important
  public static void most important(String args[]) 
    Animal A = new Animal();
    Animal h = new herbivores(); //upcasting  
	Animal o = new omnivores(); //upcasting  
    Animal c = new carnivores(); //upcasting  
    A.eat();
    h.eat();
    o.eat();  
    c.eat();  
  
    
  

Output:

Animals eat
Herbivores Eat Vegetation
Omnivores Eat Vegetation and meat
Carnivores eat meat

Instance 2:

On this instance, we’re creating one superclass Hillstations and three subclasses Manali, Mussoorie, Gulmarg. Subclasses lengthen the superclass and override its location() and famousfor() methodology. We are going to name the situation() and famousfor() methodology by the Mum or dad class’, i.e. Hillstations class. Because it refers back to the base class object and the bottom class methodology overrides the superclass methodology; the bottom class methodology is invoked at runtime. Additionally, as Java Digital Machine or the JVM and never the compiler determines methodology invocation, it’s runtime polymorphism.

class Hillstations  
  void location()
System.out.println("Location is:");
  
void famousfor()
System.out.println("Well-known for:");
  

  
class Manali extends Hillstations   
  void location()
System.out.println("Manali is in Himachal Pradesh");
  
void famousfor()
System.out.println("It's Well-known for Hadimba Temple and journey sports activities");
  
  
class Mussoorie extends Hillstations   
  void location()
System.out.println("Mussoorie is in Uttarakhand");
  
void famousfor()
System.out.println("It's Well-known for training establishments");
  
  
class Gulmarg extends Hillstations   
  void location()
System.out.println("Gulmarg is in J&Okay");
  
void famousfor()
System.out.println("It's Well-known for snowboarding");
  
  
class most important
  public static void most important(String args[]) 
    Hillstations A = new Hillstations();
    Hillstations M = new Manali();

    Hillstations Mu = new Mussoorie();

    Hillstations G = new Gulmarg();

    A.location();
A.famousfor();

M.location();
M.famousfor();

Mu.location();
Mu.famousfor();

G.location();
G.famousfor();
    
  

Output:

Location is:
Well-known for:
Manali is in Himachal Pradesh
It’s Well-known for Hadimba Temple and journey sports activities
Mussoorie is in Uttarakhand
It’s Well-known for training establishments
Gulmarg is in J&Okay
It’s Well-known for snowboarding

Instance of run-time polymorphism in java

We are going to create two lessons Automobile and Innova, Innova class will lengthen the automotive class and can override its run() methodology.

class Automobile 
 
void run() 
 
System.out.println(“ operating”); 
 

class innova extends Automobile 
 
void run(); 
 
System.out.println(“ operating quick at 120km”); 
 
public static void most important(String args[]) 
 
Automobile c = new innova(); 
c.run(); 
 
 

The output of the next program will probably be; 

Working quick at 120 km. 

One other instance for run-time polymorphism in Java

Now, allow us to examine if we will obtain runtime polymorphism by way of information members. 

class automotive 
 
int speedlimit = 125; 
 
class innova extends automotive 
{ 
int speedlimit = 135; 
public static void most important(String args[]) 
 
automotive obj = new innova(); 
System.out.println(obj.speedlimit);

The output of the next program will probably be : 

125 

This clearly implies we will’t obtain Runtime polymorphism by way of information members. Briefly, a way is overridden, not the information members.

Runtime polymorphism with multilevel inheritance

class grandfather 
 
void swim() 
 
System.out.println(“ Swimming”); 
 
 
class father extends grandfather 
 
void swim() 
 
System.out.println(“ Swimming in river”); 
 
 
class son extends father 
 
void swim() 
 
System.out.println(“ Swimming in pool”);
 
public static void most important(String args[]) 
 
grandfather f1,f2,f3; 
f1 =new grandfather(); 
f2 = new father(); 
f3 = new son(); 
f1.swim(); 
f2.swim(); 
f3.swim(): 
 
 

The output of the next program will probably be: 

Swimming, Swimming in river, Swimming in pool

One other runtime polymorphism with multilevel inheritance instance

class soundAnimal 
 
public void Sound() 
 
System.out.println("Completely different sounds of animal"); 
 
class buffalo extends soundAnimal 
 
public void Sound() 
 
System.out.println("The buffalo sound- gho,gho");  
 
class snake extends soundAnimal 
 
public void Sound() 
 
System.out.println("The snake sound- his,his");  
 
class tiger extends soundAnimal
 
public void Sound() 
 
System.out.println("The tiger sounds- roooo, rooo");  
 
public class Animal Primary 
 
public static void most important(String[] args) 
 
soundAnimal Animal = new soundAnimal(); soundAnimal buffalo = new buffalo(); 
soundAnimal snake = new snake(); 
soundAnimal tiger = new tiger(); 
Animal.Sound(); 
buffalo.Sound();
snake.Sound(); 
tiger.Sound(); 
 
 

The output of the next program will probably be; 

The buffalo sound- gho,gho 

The snake sound- his,his 

The tiger sound- roooo,roooo 

We hope you bought an thought about runtime and compile-time polymorphism.

Polymorphic Subtypes

Subtype principally implies that a subtype can function one other sort’s subtype, sounds a bit sophisticated? 

Let’s perceive this with the assistance of an instance:

Assuming we now have to attract some arbitrary shapes, we will introduce a category named ‘form’ with a draw() methodology. By overriding draw() with different subclasses similar to circle, sq., rectangle, trapezium, and many others we’ll introduce an array of sort ‘form’ whose components retailer references will discuss with ‘form’ subclass references. Subsequent time, we’ll name draw(), all shapes situations draw () methodology will probably be referred to as.

This Subtype polymorphism usually depends on upcasting and late binding. A casting the place you forged up the inheritance hierarchy from subtype to a supertype is termed upcasting.

To name non-final occasion strategies we use late binding. Briefly, a compiler mustn’t carry out any argument checks, sort checks, methodology calls, and many others, and depart all the things on the runtime. 

What’s Polymorphism in Programming?

Polymorphism in programming is outlined utilization of a single image to signify a number of differing kinds.

What’s Polymorphism Variables?

A polymorphic variable is outlined as a variable that may maintain values of various varieties through the course of execution.

Why use Polymorphism in Java?

Polymorphism in Java makes it attainable to jot down a way that may appropriately course of plenty of various kinds of functionalities which have the identical identify. We are able to additionally acquire consistency in our code through the use of polymorphism.

Benefits of Polymorphism in Java

1. It gives reusability to the code. The lessons which might be written, examined and carried out might be reused a number of instances. Moreover, it saves numerous time for the coder. Additionally, the one can change the code with out affecting the unique code.
2. A single variable can be utilized to retailer a number of information values. The worth of a variable you inherit from the superclass into the subclass might be modified with out altering that variable’s worth within the superclass; or every other subclasses.
3. With lesser strains of code, it turns into simpler for the programmer to debug the code.

Traits of Polymorphism

Polymorphism has many different traits aside from Technique Overloading and Technique Overriding. They embrace:

• Coercion
• Inner Operator Overloading
• Polymorphic Variables or Parameters

1. Coercion

Coercion offers with implicitly changing one sort of object into a brand new object of a special variety. Additionally, that is performed routinely to forestall sort errors within the code. 

Programming languages similar to C, java, and many others help the conversion of worth from one information sort to a different information sort. Knowledge sort conversions are of two varieties, i.e., implicit and specific. 

Implicit sort conversion is routinely performed in this system and this sort of conversion can be termed coercion. 

For instance, if an operand is an integer and one other one is in float, the compiler implicitly converts the integer into float worth to keep away from sort error.

Instance:

class coercion 

  public static void most important(String[] args) 
    Double space = 3.14*5*7;
System.out.println(space);
String s = "blissful";
int x=5;
String phrase = s+x;
System.out.println(phrase);

  

Output:

109.9
happy5

2. Inner Operator Overloading

In Operator Overloading, an operator or image behaves in additional methods than one relying upon the enter context or the kind of operands. It’s a attribute of static polymorphism. Though Java doesn’t help user-defined operator overloading like C++, the place the consumer can outline how an operator works for various operands, there are few situations the place Java internally overloads operators.

Operator overloading is the idea of utilizing the operator as per your alternative. Due to this fact, an operator image or methodology identify can be utilized as a ‘user-defined’ sort as per the necessities. 

For instance, ‘+’ can be utilized to carry out the addition of numbers (similar information sort) or for concatenation of two or extra strings.

Within the case of +, can be utilized for addition and in addition for concatenation.

For instance:

class coercion 

  public static void most important(String[] args) 
    
String s = "blissful";
String s1 = "world";
int x=5;
int y=10;

System.out.println(s+s1);
System.out.println(x+y);

  

Output :

Equally, operators like! &, and | are additionally within the overload place for logical and bitwise operations. In each of those instances, the kind of argument will determine how the operator will interpret.

 3. Polymorphic Variables or Parameters

In Java, the article or occasion variables signify the polymorphic variables. It is because any object variables of a category can have an IS-A relationship with their very own lessons and subclasses.

The Polymorphic Variable is a variable that may maintain values of various varieties through the time of execution.

Parametric polymorphism specifies that whereas class declaration, a discipline identify can affiliate with differing kinds, and a way identify can affiliate with completely different parameters and return varieties.

For instance:

class Form

public void show()

System.out.println("A Form.");


class Triangle extends Form

public void show()

System.out.println("I'm a triangle.");


class Primary
public static void most important(String[] args)

Form obj;
obj = new Form();
obj.show();
obj = new Triangle();
obj.show();

Output:

A Form.
I’m a triangle.

Right here, the obj object is a polymorphic variable. It is because the superclass’s similar object refers back to the mother or father class (Form) and the kid class (Triangle). 

Issues with Polymorphism 

With plenty of benefits, there are additionally a couple of disadvantages of polymorphism.

• Polymorphism is sort of difficult whereas implementation.
• It tends to cut back the readability of the code.
• It raises some critical efficiency points in real-time as effectively.

Sort Identification Throughout Downcasting 

Downcasting is termed as casting to a baby sort or casting a standard sort to a person sort.

So, we use downcasting each time we have to entry or perceive the behaviour of the subtypes. 

Instance, 

It is a hierarchical instance 

Meals> Vegetable> Ladyfinger, Tomato 

Right here, tomato and ladyfinger are two subclasses. 

In downcasting, we slender the kind of objects, which implies we’re changing widespread sort to particular person sort. 

Vegetable vegetable = new Tomato(); 

Tomato castedTomato = (Tomato) vegetable; 

Right here we’re casting widespread sort to a person sort, superclass to subclass which isn’t attainable instantly in java.

We explicitly inform the compiler what the runtime sort of the article is.

Fragile base class downside 

Fragile base class downside is nothing however a basic architectural downside. 

Typically the improper design of a mother or father class can lead a subclass of a superclass to make use of superclass in some unpredicted methods. 

The fragility of inheritance will result in damaged codes even when all the standards is met. 

This architectural downside is termed as a fragile base class downside in object-oriented programming methods and language. 

Mainly, the rationale for the delicate base downside is that the developer of the bottom class has no thought of the subclass design. There isn’t any answer but for this downside. 

Conclusion

We hope you need to have gotten a primary thought of polymorphism in Java and the way we use it in addition to issues associated to them. 

Therefore, this brings us to the tip of the weblog on Polymorphism in Java. Moreover, to be taught extra about programming and different associated ideas, take a look at the programs on Nice Studying Academy and PG Applications in Software program Engineering.  

Additionally, in case you are getting ready for Interviews, take a look at these Interview Questions for Java to ace it like a professional.

So, don’t cease your journey of studying. Additionally, don’t overlook to upskill and reskill your self. Preserve exploring and continue to learn.

Continuously Requested Questions

Participating within the research of Java programming suggests a eager curiosity within the realm of software program improvement. For these embarking upon this journey with aspirations in direction of a profession on this discipline, it’s endorsed to discover the next pages as a way to purchase a complete understanding of the event profession path: