Polymorphism in Java with Examples in 2023

What’s Polymorphism in Java?

Polymorphism in Java is the duty that plays a unmarried motion in several tactics.

So, languages that don’t fortify polymorphism don’t seem to be ‘Object-Orientated Languages’, however ‘Object-Based totally Languages’. Ada, for example, is one such language. Since Java helps polymorphism, it’s an Object-Orientated Language.

Polymorphism happens when there’s inheritance, i.e., many categories are similar.

Inheritance is a formidable function in Java. Java Inheritance shall we one magnificence gain the houses and attributes of any other magnificence. Polymorphism in Java lets in us to make use of those inherited houses to accomplish other duties. Thus, permitting us to succeed in the similar motion in many various tactics.

What’s Polymorphism?

The derivation of the phrase Polymorphism is from two other Greek words- poly and morphs. “Poly” way a lot of, and “Morphs” way bureaucracy. So, polymorphism way innumerable bureaucracy. Polymorphism, subsequently, is without doubt one of the most important options of Object-Orientated Programming.

Actual-Lifestyles Examples of Polymorphism

A person could have other relationships with other folks. A lady is usually a mom, a daughter, a sister, and a chum, all on the identical time, i.e. she plays different behaviors in several eventualities.

The human frame has other organs. Each organ has a special serve as to accomplish; the center is liable for blood waft, the lungs for respiring, the mind for cognitive job, and the kidneys for excretion. So we’ve got a typical means serve as that plays otherwise relying upon the organ of the frame. 

Polymorphism in Java Instance

A superclass named “Shapes” has a technique referred to as “space()”. Subclasses of “Shapes” can also be “Triangle”, “circle”, “Rectangle”, and so on. Each and every subclass has its means of calculating space. The use of Inheritance and Polymorphism way, the subclasses can use the “space()” approach to in finding the realm’s formulation for that form.

magnificence Shapes {
  public void space() {
    Machine.out.println("The formulation for space of ");
  }
}
magnificence Triangle extends Shapes {
  public void space() {
    Machine.out.println("Triangle is ½ * base * peak ");
  }
}
magnificence Circle extends Shapes {
  public void space() {
    Machine.out.println("Circle is 3.14 * radius * radius ");
  }
}
magnificence Major {
  public static void major(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 formulation for the realm of the Triangle is ½ * base * peak
The formulation for the realm of the Circle is 3.14 * radius * radius

magnificence Form {
    public void draw() {
        Machine.out.println("Drawing a form");
    }
}

magnificence Circle extends Form {
    @Override
    public void draw() {
        Machine.out.println("Drawing a circle");
    }
}

magnificence Sq. extends Form {
    @Override
    public void draw() {
        Machine.out.println("Drawing a sq.");
    }
}

magnificence Major {
    public static void major(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’ve got a base magnificence Form with a unmarried means draw() that prints “Drawing a form” to the console. We then create two subclasses, Circle and Sq., that override the draw() approach to print “Drawing a circle” and “Drawing a sq.” respectively.

Within the major means, we create two circumstances of the Form magnificence, s1 and s2, that are in reality circumstances of the Circle and Sq. subclasses. After we name the draw() means on those gadgets, the right kind implementation is named in keeping with the real form of the thing, that is run-time polymorphism. This system will output: “Drawing a circle” and “Drawing a sq.”

On this instance, the draw() means is overridden within the subclasses, and this permits for this system to resolve which means to make use of at runtime. That is referred to as runtime polymorphism or dynamic polymorphism, As a result of at runtime the JVM determines the real form of the thing and calls the corresponding means.

Additionally Learn: OOPs ideas in Java

Forms of Polymorphism

You’ll carry out Polymorphism in Java by the use of two other strategies:

1. Manner Overloading
2. Manner Overriding

What’s Manner Overloading in Java?

Manner overloading is the method that may create more than one strategies of the similar identify in the similar magnificence, and all of the strategies paintings in several tactics. Manner overloading happens when there’s a couple of means of the similar identify within the magnificence.

Instance of Manner Overloading in Java

magnificence Shapes {
  public void space() {
    Machine.out.println("To find space ");
  }
public void space(int r) {
    Machine.out.println("Circle space = "+3.14*r*r);
  }

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


}

magnificence Major {
  public static void major(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:

To find space
Circle space = 78.5
Triangle space=3.60
Rectangle space=12

What’s Manner Overriding in Java?

Manner overriding is the method when the subclass or a kid magnificence has the similar means as declared within the dad or mum magnificence.

Instance of Manner Overriding in Java

magnificence Car{  
  //defining a technique  
  void run(){Machine.out.println("Car is shifting");}  
}  
//Growing a kid magnificence  
magnificence Car2 extends Car{  
  //defining the similar means as within the dad or mum magnificence  
  void run(){Machine.out.println("automobile is working safely");}  
  
  public static void major(String args[]){  
  Car2 obj = new Car2();//developing object  
  obj.run();//calling means  
  }  
}  

Output:

Automotive is working safely

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

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

What’s Assemble-Time Polymorphism in Java?

Assemble Time Polymorphism In Java is often referred to as Static Polymorphism. Moreover, the decision to the process is resolved at compile-time. Assemble-Time polymorphism is completed thru Manner Overloading. This kind of polymorphism may also be completed thru Operator Overloading. Alternatively, Java does now not fortify Operator Overloading.

Manner Overloading is when a category has more than one strategies with the similar identify, however the quantity, varieties, and order of parameters and the go back form of the strategies are other. Java lets in the consumer freedom to make use of the similar identify for quite a lot of purposes so long as it will possibly distinguish between them by way of the sort and choice of parameters. Take a look at one of the most essential questions about run time polymorphism in java interview questions.

Instance of Assemble-Time Polymorphism in Java

We will be able to do addition in Java and perceive the concept that of bring together time polymorphism the use of subtract() 

package deal staticPolymorphism; 
public magnificence Addition 
{ 
void sum(int a, int b) 
{ 
int c = a+b; 
Machine.out.println(“ Addition of 2 numbers :” +c); } 
void sum(int a, int b, int e) 
{ 
int c = a+b+e; 
Machine.out.println(“ Addition of 3 numbers :” +c); } 
public static void major(String[] args) 
{ 
Addition obj = new Addition(); 
obj.sum ( 30,90); 
obj.sum(45, 80, 22); 
} 
}

The output of this system shall be: 

Sum of 2 numbers: 120 

Sum of 3 numbers: 147 

On this program, the sum() means overloads with two varieties by the use of other parameters. 

That is the elemental idea of compile-time polymorphism in java the place we will be able to carry out quite a lot of operations by way of the use of more than one strategies having the similar identify.

What’s Runtime Polymorphism in Java?

Runtime polymorphism in Java may be popularly referred to as Dynamic Binding or Dynamic Manner Dispatch. On this procedure, the decision to an overridden means is resolved dynamically at runtime quite than at compile-time. You’ll succeed in Runtime polymorphism by the use of Manner Overriding.

Manner Overriding is completed when a kid or a subclass has a technique with the similar identify, parameters, and go back kind because the dad or mum or the superclass; then that serve as overrides the serve as within the superclass. In more practical phrases, if the subclass supplies its definition to a technique already provide within the superclass; then that serve as within the base magnificence is alleged to be overridden.

Additionally, it must be famous that runtime polymorphism can simplest be completed thru purposes and now not knowledge participants. 

Overriding is completed by way of the use of a reference variable of the superclass. The approach to be referred to as is made up our minds in keeping with the thing which is being referred to by way of the reference variable. That is often referred to as Upcasting.

Upcasting takes position when the Father or mother magnificence’s reference variable refers back to the object of the kid magnificence. For instance:

magnificence A{} 
magnificence B extends A{}  
A a=new B(); //upcasting

Examples of Runtime Polymorphism in Java

Instance 1:

On this instance, we’re developing one superclass Animal and 3 subclasses, Herbivores, Carnivores, and Omnivores. Subclasses lengthen the superclass and override its consume() means. We will be able to name the consume() means by way of the reference variable of Father or mother magnificence, i.e. Animal magnificence. Because it refers back to the base magnificence object and the bottom magnificence means overrides the superclass means; the bottom magnificence means is invoked at runtime. As Java Digital Gadget or the JVM and now not the compiler determines means invocation, it’s, subsequently, runtime polymorphism.

magnificence Animal{  
  void consume(){
Machine.out.println("Animals Consume");
}  
}  
magnificence herbivores extends Animal{  
  void consume(){
Machine.out.println("Herbivores Consume Crops");
} 
  }
magnificence omnivores extends Animal{  
  void consume(){
Machine.out.println("Omnivores Consume Crops and meat");
} 
  }
magnificence carnivores extends Animal{  
  void consume(){
Machine.out.println("Carnivores Consume meat");
} 
  }
magnificence major{
  public static void major(String args[]){ 
    Animal A = new Animal();
    Animal h = new herbivores(); //upcasting  
	Animal o = new omnivores(); //upcasting  
    Animal c = new carnivores(); //upcasting  
    A.consume();
    h.consume();
    o.consume();  
    c.consume();  
  
  }  
}  

Output:

Animals consume
Herbivores Consume Crops
Omnivores Consume Crops and meat
Carnivores consume meat

Instance 2:

On this instance, we’re developing one superclass Hillstations and 3 subclasses Manali, Mussoorie, Gulmarg. Subclasses lengthen the superclass and override its location() and famousfor() means. We will be able to name the site() and famousfor() means by way of the Father or mother magnificence’, i.e. Hillstations magnificence. Because it refers back to the base magnificence object and the bottom magnificence means overrides the superclass means; the bottom magnificence means is invoked at runtime. Additionally, as Java Digital Gadget or the JVM and now not the compiler determines means invocation, it’s runtime polymorphism.

magnificence Hillstations{  
  void location(){
Machine.out.println("Location is:");
}  
void famousfor(){
Machine.out.println("Well-known for:");
}  

}  
magnificence Manali extends Hillstations {  
  void location(){
Machine.out.println("Manali is in Himachal Pradesh");
}  
void famousfor(){
Machine.out.println("It's Well-known for Hadimba Temple and journey sports activities");
}  
  }
magnificence Mussoorie extends Hillstations {  
  void location(){
Machine.out.println("Mussoorie is in Uttarakhand");
}  
void famousfor(){
Machine.out.println("It's Well-known for schooling establishments");
}  
  }
magnificence Gulmarg extends Hillstations {  
  void location(){
Machine.out.println("Gulmarg is in J&Ok");
}  
void famousfor(){
Machine.out.println("It's Well-known for snowboarding");
}  
  }
magnificence major{
  public static void major(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&Ok
It’s Well-known for snowboarding

Instance of run-time polymorphism in java

We will be able to create two categories Automotive and Innova, Innova magnificence will lengthen the auto magnificence and can override its run() means.

magnificence Automotive 
{ 
void run() 
{ 
Machine.out.println(“ working”); 
} 
}
magnificence innova extends Automotive 
{ 
void run(); 
{ 
Machine.out.println(“ working rapid at 120km”); 
} 
public static void major(String args[]) 
{ 
Automotive c = new innova(); 
c.run(); 
} 
} 

The output of the next program shall be; 

Operating rapid at 120 km. 

Every other instance for run-time polymorphism in Java

Now, allow us to take a look at if we will be able to succeed in runtime polymorphism by the use of knowledge participants. 

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

The output of the next program shall be : 

125 

This obviously implies we will be able to’t succeed in Runtime polymorphism by the use of knowledge participants. Briefly, a technique is overridden, now not the information participants.

Runtime polymorphism with multilevel inheritance

magnificence grandfather 
{ 
void swim() 
{ 
Machine.out.println(“ Swimming”); 
} 
} 
magnificence father extends grandfather 
{ 
void swim() 
{ 
Machine.out.println(“ Swimming in river”); 
} 
} 
magnificence son extends father 
{ 
void swim() 
{ 
Machine.out.println(“ Swimming in pool”);
} 
public static void major(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

Every other runtime polymorphism with multilevel inheritance instance

magnificence soundAnimal 
{ 
public void Sound() 
{ 
Machine.out.println("Other sounds of animal"); }
} 
magnificence buffalo extends soundAnimal 
{ 
public void Sound() 
{ 
Machine.out.println("The buffalo sound- gho,gho"); } 
} 
magnificence snake extends soundAnimal 
{ 
public void Sound() 
{ 
Machine.out.println("The snake sound- his,his"); } 
} 
magnificence tiger extends soundAnimal
{ 
public void Sound() 
{ 
Machine.out.println("The tiger sounds- roooo, rooo"); } 
} 
public magnificence Animal Major 
{ 
public static void major(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 are hoping you were given an concept about runtime and compile-time polymorphism.

Polymorphic Subtypes

Subtype mainly implies that a subtype can function any other kind’s subtype, sounds a bit of difficult? 

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

Assuming we need to draw some arbitrary shapes, we will be able to introduce a category named ‘form’ with a draw() means. Via overriding draw() with different subclasses equivalent to circle, sq., rectangle, trapezium, and so on we will be able to introduce an array of kind ‘form’ whose parts retailer references will check with ‘form’ subclass references. Subsequent time, we will be able to name draw(), all shapes circumstances draw () means shall be referred to as.

This Subtype polymorphism typically will depend on upcasting and overdue binding. A casting the place you solid up the inheritance hierarchy from subtype to a supertype is termed upcasting.

To name non-final example strategies we use overdue binding. Briefly, a compiler must now not carry out any argument tests, kind tests, means calls, and so on, and go away the whole lot at the runtime. 

What’s Polymorphism in Programming?

Polymorphism in programming is explained utilization of a unmarried image to constitute more than one differing kinds.

What’s Polymorphism Variables?

A polymorphic variable is explained as a variable that may hang values of various varieties all through the process execution.

Why use Polymorphism in Java?

Polymorphism in Java makes it imaginable to put in writing a technique that may accurately procedure loads of various kinds of functionalities that experience the similar identify. We will be able to additionally achieve consistency in our code by way of the use of polymorphism.

Benefits of Polymorphism in Java

1. It supplies reusability to the code. The categories which might be written, examined and carried out can also be reused more than one instances. Moreover, it saves numerous time for the coder. Additionally, the only can alternate the code with out affecting the unique code.
2. A unmarried variable can be utilized to retailer more than one knowledge values. The price of a variable you inherit from the superclass into the subclass can also be modified with out converting that variable’s worth within the superclass; or every other subclasses.
3. With lesser strains of code, it turns into more uncomplicated for the programmer to debug the code.

Traits of Polymorphism

Polymorphism has many different traits as opposed to Manner Overloading and Manner Overriding. They come with:

• Coercion
• Inner Operator Overloading
• Polymorphic Variables or Parameters

1. Coercion

Coercion offers with implicitly changing one form of object into a brand new object of a special sort. Additionally, that is carried out routinely to stop kind mistakes within the code. 

Programming languages equivalent to C, java, and so on fortify the conversion of worth from one knowledge kind to any other knowledge kind. Knowledge kind conversions are of 2 varieties, i.e., implicit and particular. 

Implicit kind conversion is routinely carried out in this system and this sort of conversion may be termed coercion. 

For instance, if an operand is an integer and any other one is in glide, the compiler implicitly converts the integer into glide worth to steer clear of kind error.

Instance:

magnificence coercion {

  public static void major(String[] args) {
    Double space = 3.14*5*7;
Machine.out.println(space);
String s = "satisfied";
int x=5;
String phrase = s+x;
Machine.out.println(phrase);

  }
}

Output:

109.9
happy5

2. Inner Operator Overloading

In Operator Overloading, an operator or image behaves in additional tactics than one relying upon the enter context or the kind of operands. This is a function of static polymorphism. Even if Java does now not fortify user-defined operator overloading like C++, the place the consumer can outline how an operator works for various operands, there are few circumstances the place Java internally overloads operators.

Operator overloading is the concept that of the use of the operator as in line with your selection. Subsequently, an operator image or means identify can be utilized as a ‘user-defined’ kind as in line with the necessities. 

For instance, ‘+’ can be utilized to accomplish the addition of numbers (identical knowledge kind) or for concatenation of 2 or extra strings.

In relation to +, can be utilized for addition and in addition for concatenation.

For instance:

magnificence coercion {

  public static void major(String[] args) {
    
String s = "satisfied";
String s1 = "international";
int x=5;
int y=10;

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

  }
}

Output :

In a similar way, operators like! &, and | also are within the overload place for logical and bitwise operations. In either one of those circumstances, the kind of argument will make a decision how the operator will interpret.

 3. Polymorphic Variables or Parameters

In Java, the thing or example variables constitute the polymorphic variables. It is because any object variables of a category could have an IS-A courting with their very own categories and subclasses.

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

Parametric polymorphism specifies that whilst magnificence declaration, a box identify can go together with differing kinds, and a technique identify can go together with other parameters and go back varieties.

For instance:

magnificence Form
{
public void show()
{
Machine.out.println("A Form.");
}
}
magnificence Triangle extends Form
{
public void show()
{
Machine.out.println("I'm a triangle.");
}
}
magnificence Major{
public static void major(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 identical object refers back to the dad or mum magnificence (Form) and the kid magnificence (Triangle). 

Issues of Polymorphism 

With loads of benefits, there also are a couple of disadvantages of polymorphism.

• Polymorphism is reasonably difficult whilst implementation.
• It has a tendency to scale back the clarity of the code.
• It raises some critical efficiency problems in real-time as smartly.

Kind Id All over Downcasting 

Downcasting is termed as casting to a kid kind or casting a commonplace kind to a person kind.

So, we use downcasting on every occasion we wish to get entry to 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 gadgets, this means that we’re changing commonplace kind to particular person kind. 

Vegetable vegetable = new Tomato(); 

Tomato castedTomato = (Tomato) vegetable; 

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

We explicitly inform the compiler what the runtime form of the thing is.

Fragile base magnificence downside 

Fragile base magnificence downside is not anything however a elementary architectural downside. 

Now and again the wrong design of a dad or mum magnificence can lead a subclass of a superclass to make use of superclass in some unpredicted tactics. 

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

This architectural downside is termed as a delicate base magnificence downside in object-oriented programming programs and language. 

Mainly, the cause of the delicate base downside is that the developer of the bottom magnificence has no thought of the subclass design. There is not any resolution but for this downside. 

Conclusion

We are hoping you should have were given a fundamental thought of polymorphism in Java and the way we use it in addition to issues associated with them. 

Therefore, this brings us to the top of the weblog on Polymorphism in Java. Moreover, to be informed extra about programming and different similar ideas, take a look at the classes on Nice Studying Academy and PG Systems in Tool Engineering.  

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

So, don’t prevent your adventure of studying. Additionally, don’t disregard to upskill and reskill your self. Stay exploring and continue to learn.

Incessantly Requested Questions

Take step one against achieving your targets by way of enrolling on this instrument engineering direction now!!!