Polymorphismus in Java ist ein Konzept, mit dem wir a durchführen können einzelne Aktion auf unterschiedliche Weise . Polymorphismus leitet sich von zwei griechischen Wörtern ab: poly und morphs. Das Wort „Poly“ bedeutet „viele“ und „Morphs“ bedeutet Formen. Polymorphismus bedeutet also viele Formen.

In Java gibt es zwei Arten von Polymorphismus: Polymorphismus zur Kompilierungszeit und Polymorphismus zur Laufzeit. Wir können Polymorphismus in Java durch Methodenüberladung und Methodenüberschreibung durchführen.

Wenn Sie eine statische Methode in Java überladen, handelt es sich um ein Beispiel für Polymorphismus zur Kompilierungszeit. Hier konzentrieren wir uns auf den Laufzeitpolymorphismus in Java.

Laufzeitpolymorphismus in Java

Laufzeitpolymorphismus oder Dynamischer Methodenversand ist ein Prozess, bei dem ein Aufruf einer überschriebenen Methode zur Laufzeit und nicht zur Kompilierungszeit aufgelöst wird.

Dabei wird eine überschriebene Methode über die Referenzvariable einer Oberklasse aufgerufen. Die Bestimmung der aufzurufenden Methode basiert auf dem Objekt, auf das sich die Referenzvariable bezieht.

Lassen Sie uns zunächst das Upcasting vor dem Laufzeitpolymorphismus verstehen.

Upcasting

Wenn die Referenzvariable der übergeordneten Klasse auf das Objekt der untergeordneten Klasse verweist, spricht man von Upcasting. Zum Beispiel:

 class A{} class B extends A{} 

 A a=new B();//upcasting 

Für das Upcasting können wir die Referenzvariable vom Klassentyp oder einen Schnittstellentyp verwenden. Zum Beispiel:

 interface I{} class A{} class B extends A implements I{} 

Hier wäre die Beziehung der B-Klasse:

 B IS-A A B IS-A I B IS-A Object 

Da Object die Stammklasse aller Klassen in Java ist, können wir B IS-A Object schreiben.

Beispiel für Java-Laufzeitpolymorphismus

In diesem Beispiel erstellen wir zwei Klassen Bike und Splendor. Die Splendor-Klasse erweitert die Bike-Klasse und überschreibt deren run()-Methode. Wir rufen die run-Methode über die Referenzvariable der übergeordneten Klasse auf. Da es sich auf das Unterklassenobjekt bezieht und die Unterklassenmethode die übergeordnete Klassenmethode überschreibt, wird die Unterklassenmethode zur Laufzeit aufgerufen.

Da der Methodenaufruf von der JVM und nicht vom Compiler bestimmt wird, spricht man von Laufzeitpolymorphismus.

 class Bike{ void run(){System.out.println('running');} } class Splendor extends Bike{ void run(){System.out.println('running safely with 60km');} public static void main(String args[]){ Bike b = new Splendor();//upcasting b.run(); } } 

Ausgabe:

 running safely with 60km. 

Beispiel für Java-Laufzeitpolymorphismus: Bank

Stellen Sie sich ein Szenario vor, in dem Bank eine Klasse ist, die eine Methode zum Ermitteln des Zinssatzes bereitstellt. Allerdings kann der Zinssatz je nach Bank unterschiedlich sein. Beispielsweise bieten die Banken SBI, ICICI und AXIS Zinssätze von 8,4 %, 7,3 % und 9,7 %.

Hinweis: Dieses Beispiel wird auch beim Überschreiben von Methoden angegeben, es erfolgte jedoch kein Upcasting.

 class Bank{ float getRateOfInterest(){return 0;} } class SBI extends Bank{ float getRateOfInterest(){return 8.4f;} } class ICICI extends Bank{ float getRateOfInterest(){return 7.3f;} } class AXIS extends Bank{ float getRateOfInterest(){return 9.7f;} } class TestPolymorphism{ public static void main(String args[]){ Bank b; b=new SBI(); System.out.println('SBI Rate of Interest: '+b.getRateOfInterest()); b=new ICICI(); System.out.println('ICICI Rate of Interest: '+b.getRateOfInterest()); b=new AXIS(); System.out.println('AXIS Rate of Interest: '+b.getRateOfInterest()); } } 

Ausgabe:

 SBI Rate of Interest: 8.4 ICICI Rate of Interest: 7.3 AXIS Rate of Interest: 9.7 

Beispiel für Java-Laufzeitpolymorphismus: Form

 class Shape{ void draw(){System.out.println('drawing...');} } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle...');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle...');} } class Triangle extends Shape{ void draw(){System.out.println('drawing triangle...');} } class TestPolymorphism2{ public static void main(String args[]){ Shape s; s=new Rectangle(); s.draw(); s=new Circle(); s.draw(); s=new Triangle(); s.draw(); } } 

Ausgabe:

 drawing rectangle... drawing circle... drawing triangle... 

Beispiel für Java-Laufzeitpolymorphismus: Tier

 class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void eat(){System.out.println('eating bread...');} } class Cat extends Animal{ void eat(){System.out.println('eating rat...');} } class Lion extends Animal{ void eat(){System.out.println('eating meat...');} } class TestPolymorphism3{ public static void main(String[] args){ Animal a; a=new Dog(); a.eat(); a=new Cat(); a.eat(); a=new Lion(); a.eat(); }} 

Ausgabe:

 eating bread... eating rat... eating meat... 

Java-Laufzeitpolymorphismus mit Datenelement

Eine Methode wird überschrieben, nicht die Datenelemente, daher kann durch Datenelemente kein Laufzeitpolymorphismus erreicht werden.

Im folgenden Beispiel haben beide Klassen eine Geschwindigkeitsbegrenzung für Datenelemente. Wir greifen auf das Datenelement über die Referenzvariable der übergeordneten Klasse zu, die auf das Unterklassenobjekt verweist. Da wir auf das Datenelement zugreifen, das nicht überschrieben wird, greift es immer auf das Datenelement der übergeordneten Klasse zu.

Regel: Laufzeitpolymorphismus kann durch Datenelemente nicht erreicht werden.

 class Bike{ int speedlimit=90; } class Honda3 extends Bike{ int speedlimit=150; public static void main(String args[]){ Bike obj=new Honda3(); System.out.println(obj.speedlimit);//90 } } 

Ausgabe:

 90 

Java-Laufzeitpolymorphismus mit mehrstufiger Vererbung

Sehen wir uns das einfache Beispiel des Laufzeitpolymorphismus mit mehrstufiger Vererbung an.

 class Animal{ void eat(){System.out.println('eating');} } class Dog extends Animal{ void eat(){System.out.println('eating fruits');} } class BabyDog extends Dog{ void eat(){System.out.println('drinking milk');} public static void main(String args[]){ Animal a1,a2,a3; a1=new Animal(); a2=new Dog(); a3=new BabyDog(); a1.eat(); a2.eat(); a3.eat(); } } 

Ausgabe:

 eating eating fruits drinking Milk 

Versuchen Sie es mit der Ausgabe

 class Animal{ void eat(){System.out.println('animal is eating...');} } class Dog extends Animal{ void eat(){System.out.println('dog is eating...');} } class BabyDog1 extends Dog{ public static void main(String args[]){ Animal a=new BabyDog1(); a.eat(); }} 

Ausgabe:

 Dog is eating 

Da BabyDog die Methode eat() nicht überschreibt, wird die Methode eat() der Klasse Dog aufgerufen.