Tuesday, October 4, 2022
HomeArtificial IntelligencePolymorphism in Java with Examples

Polymorphism in Java with Examples


Polymorphism in Java

Polymorphism is the flexibility of an object to tackle totally different varieties. In Java, polymorphism refers back to the capacity of a category to supply totally different implementations of a way, relying on the kind of object that’s handed to the strategy.

To place it merely, polymorphism in Java permits us to carry out the identical motion in many alternative methods. Any Java object that may go multiple IS-A take a look at is polymorphic in Java. Due to this fact, all of the Java objects are polymorphic because it has handed the IS-A take a look at for their very own kind and for the category Object.

This text additionally talks about two sorts of polymorphism in Java: compile time polymorphism and runtime polymorphism, Java polymorphism examples, technique overloading, technique overriding, why to make use of polymorphism in java, java programming, and plenty of extra.

Polymorphism is a function of the object-oriented programming language, Java, which suggests you could carry out a single job in several methods. Within the technical world, polymorphism in Java permits one to do a number of implementations by defining one interface. 

  1. What’s Polymorphism?
  2. What’s Polymorphism in Java?
  3. Actual-Life Examples of Polymorphism
  4. Kinds of Polymorphism
  5. Technique Overloading in Java
  6. Technique Overriding in Java
  7. Runtime Polymorphism in Java
  8. Compile-Time Polymorphism in Java
  9. Polymorphism in programming
  10. Polymorphism variables
  11. Why use Polymorphism in Java?
  12. Traits of Polymorphism
  13. Issues with Polymorphism
  14. Conclusion
  15. FAQs

What’s Polymorphism?

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

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 aren’t ‘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. there are numerous courses which are associated to one another.

Inheritance is a strong function 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 totally different duties. Thus, permitting us to realize the identical motion in many alternative methods.

Actual-Life Examples of Polymorphism

A person can have totally different relationships with totally different individuals. A lady generally is a mom, a daughter, a sister, a good friend, all on the similar time, i.e. she performs different behaviours in several conditions.

The human physique has totally different organs. Each organ has a unique operate to carry out; the guts is answerable for blood circulation, lungs for respiration, mind for cognitive exercise, and kidneys for excretion. So now we have a normal technique operate that performs otherwise relying upon the organ of the physique. 

Polymorphism in Java Instance

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

class Shapes {
  public void space() {
    System.out.println("The components 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 Principal {
  public static void principal(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 components for the world of Triangle is ½ * base * peak
The components for the world of the Circle is 3.14 * radius * radius

Additionally Learn: OOPs ideas in Java

Kinds of Polymorphism

You’ll be able to carry out Polymorphism in Java by way of two totally 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 title in the identical class, and all of the strategies work in several methods. Technique overloading happens when there may be multiple technique of the identical title 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 Principal {
  public static void principal(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 technique as declared within the mum or dad class.

Instance of Technique Overriding in Java

class Automobile{  
  //defining a way  
  void run(){System.out.println("Automobile is shifting");}  
}  
//Creating a baby class  
class Car2 extends Automobile{  
  //defining the identical technique as within the mum or dad class  
  void run(){System.out.println("automobile is working safely");}  
  
  public static void principal(String args[]){  
  Car2 obj = new Car2();//creating object  
  obj.run();//calling technique  
  }  
}  

Output:

Automotive is working safely

Additionally, Polymorphism in Java will be categorised 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 referred to as Static Polymorphism. Moreover, the decision to the strategy is resolved at compile-time. Compile-Time polymorphism is achieved via Technique Overloading. Any such polymorphism can be achieved via Operator Overloading. Nonetheless, Java doesn’t help Operator Overloading.

Technique Overloading is when a category has a number of strategies with the identical title, however the quantity, varieties, and order of parameters and the return kind of the strategies are totally different. Java permits the person freedom to make use of the identical title for numerous capabilities so long as it could distinguish between them by the kind and variety of parameters. 

Instance of Compile-Time Polymorphism in Java

We’ll 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 principal(String[] args) 
{ 
Addition obj = new Addition(); 
obj.sum ( 30,90); 
obj.sum(45, 80, 22); 
} 
}

The output of this system shall be: 

Sum of two numbers: 120 

Sum of three numbers: 147 

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

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

What’s Runtime Polymorphism in Java?

Runtime polymorphism in Java can also be popularly generally known as Dynamic Binding or Dynamic Technique Dispatch. On this course of, the decision to an overridden technique is resolved dynamically at runtime slightly than at compile-time. You’ll be able to obtain Runtime polymorphism by way of Technique Overriding.

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

Additionally, it ought to be famous that runtime polymorphism can solely be achieved via capabilities and never knowledge members. 

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

Upcasting takes place when the Guardian 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 prolong the superclass and override its eat() technique. We’ll name the eat() technique by the reference variable of Guardian class, i.e. Animal class. Because it refers back to the base class object and the bottom class technique overrides the superclass technique; the bottom class technique is invoked at runtime. As Java Digital Machine or the JVM and never the compiler determines technique 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 principal{
  public static void principal(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 prolong the superclass and override its location() and famousfor() technique. We’ll name the situation() and famousfor() technique by the Guardian class’, i.e. Hillstations class. Because it refers back to the base class object and the bottom class technique overrides the superclass technique; the bottom class technique is invoked at runtime. Additionally, as Java Digital Machine or the JVM and never the compiler determines technique 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 schooling 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 principal{
  public static void principal(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 schooling establishments
Gulmarg is in J&Okay
It’s Well-known for snowboarding

Instance of run-time polymorphism in java

We’ll create two courses Automotive and Innova, Innova class will prolong the automobile class and can override its run() technique.

class Automotive 
{ 
void run() 
{ 
System.out.println(“ working”); 
} 
}
class innova extends Automotive 
{ 
void run(); 
{ 
System.out.println(“ working quick at 120km”); 
} 
public static void principal(String args[]) 
{ 
Automotive c = new innova(); 
c.run(); 
} 
} 

The output of the next program shall be; 

Working quick at 120 km. 

One other instance for run-time polymorphism in Java

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

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

The output of the next program shall be : 

125 

This clearly implies we will’t obtain Runtime polymorphism by way of knowledge 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 principal(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 shall be: 

Swimming, Swimming in river, Swimming in pool

One other runtime polymorphism with multilevel inheritance instance

class soundAnimal 
{ 
public void Sound() 
{ 
System.out.println("Totally 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 Principal 
{ 
public static void principal(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 shall 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 signifies that a subtype can function one other kind’s subtype, sounds a bit difficult? 

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

Assuming now we have to attract some arbitrary shapes, we will introduce a category named ‘form’ with a draw() technique. By overriding draw() with different subclasses resembling circle, sq., rectangle, trapezium, and many others we’ll introduce an array of kind ‘form’ whose components retailer references will check with ‘form’ subclass references. Subsequent time, we’ll name draw(), all shapes cases draw () technique shall be known as.

This Subtype polymorphism usually depends on upcasting and late binding. A casting the place you solid 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, kind checks, technique calls, and many others, and depart all the pieces on the runtime. 

What’s Polymorphism in Programming?

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

What’s Polymorphism Variables?

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

Why use Polymorphism in Java?

Polymorphism in Java makes it potential to write down a way that may accurately course of numerous various kinds of functionalities which have the identical title. We are able to additionally achieve consistency in our code through the use of polymorphism.

Benefits of Polymorphism in Java

  1. It gives reusability to the code. The courses which are written, examined and carried out will be reused a number of occasions. Moreover, it saves a whole lot of 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 knowledge values. The worth of a variable you inherit from the superclass into the subclass will be modified with out altering that variable’s worth within the superclass; or every other subclasses.
  3. With lesser traces 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 kind of object into a brand new object of a unique type. Additionally, that is executed routinely to forestall kind errors within the code. 

Programming languages resembling C, java, and many others help the conversion of worth from one knowledge kind to a different knowledge kind. Information kind conversions are of two varieties, i.e., implicit and specific. 

Implicit kind conversion is routinely executed in this system and one of these conversion can also 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 kind error.

Instance:

class coercion {

  public static void principal(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 person can outline how an operator works for various operands, there are few cases the place Java internally overloads operators.

Operator overloading is the idea of utilizing the operator as per your selection. Due to this fact, an operator image or technique title can be utilized as a ‘user-defined’ kind as per the necessities. 

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

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

For instance:

class coercion {

  public static void principal(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 resolve how the operator will interpret.

 3. Polymorphic Variables or Parameters

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

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

Parametric polymorphism specifies that whereas class declaration, a subject title can affiliate with differing kinds, and a way title can affiliate with totally 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 Principal{
public static void principal(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 mum or dad class (Form) and the kid class (Triangle). 

Issues with Polymorphism 

With numerous 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 properly.

Kind Identification Throughout Downcasting 

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

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

Instance, 

This can be a hierarchical instance 

Meals> Vegetable> Ladyfinger, Tomato 

Right here, tomato and ladyfinger are two subclasses. 

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

Vegetable vegetable = new Tomato(); 

Tomato castedTomato = (Tomato) vegetable; 

Right here we’re casting widespread kind to a person kind, superclass to subclass which isn’t potential immediately in java.

We explicitly inform the compiler what the runtime kind 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 mum or dad 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 programs and language. 

Mainly, the explanation for the delicate base downside is that the developer of the bottom class has no thought of the subclass design. There is no such thing as a answer but for this downside. 

Conclusion

We hope you will need to have gotten a fundamental 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 making 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.

Steadily Requested Questions

What’s polymorphism with instance?

One of many OOPs options that enables us to hold out a single motion in numerous methods is called polymorphism in Java. For instance, now we have a category Animal with a way sound(). This can be a generic class and so we can’t give it an implementation resembling: Meow, Oink, Roar, and many others. 

What are the 4 sorts of polymorphism?

The 4 sorts of polymorphism are:
– Runtime or Subtype polymorphism
– Overloading or Parametric polymorphism
– Compile-time or Advert hoc polymorphism
– Casting or Coercion polymorphism

What’s polymorphism in OOPs?

One of many core ideas of OOP or object-oriented programming, polymorphism describes conditions through which a particualr factor happens in several varieties. In laptop science, polymorphism describes an idea that enables us to entry various kinds of objects via the identical interface.

What’s overriding in OOP?

In object-oriented programming, overriding is a function that enables a subclass or little one class to supply a selected implementation of a way that’s already offered by one among its superclasses or mum or dad courses.

What’s overriding vs overloading?

If two or extra strategies in the identical class have the identical title, however have totally different parameters, this is called Overloading. In case of Overriding, a way signature (title and parameters) are present in the identical superclass and the kid class.

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments