Laufzeitpolymorphismus in Java

In diesem Artikel lernen wir etwas über Laufzeitpolymorphismus in Java. „Poly“ bedeutet „viele“ und „Morph“ bedeutet „Typ“. Der Begriff Polymorphismus bezeichnet also dasselbe in verschiedenen Typen. Hier werden wir sehen, wie Java Polymorphismus zur Laufzeit archiviert, also nach der Kompilierung, aber vor der Ausführung des Codes.

Syntax:

WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 Probetests

Für Laufzeitpolymorphismus in Java sollten Sie die grundlegende Java-Syntax mit Anmerkungen befolgen.

@Override

Die Anmerkung kann hier verwendet werden, um darauf hinzuweisen, welche Methode wir konkret überschreiben möchten.

Wie funktioniert Laufzeitpolymorphismus in Java?

Laufzeitpolymorphismus funktioniert in Java durch Methodenüberschreibung. Das Überschreiben von Methoden erfolgt, wenn Objekte denselben Methodennamen, dieselben Argumente und denselben Typ wie ihre übergeordnete Klasse haben, jedoch eine andere Funktionalität aufweisen. Wenn eine untergeordnete Klasse diese Art von Methode enthält, nennen wir sie eine überschriebene Methode.

Warum heißt es Laufzeitpolymorphismus?

Wenn wir eine überschriebene Methode einer untergeordneten Klasse über ihre übergeordnete Typreferenz aufrufen (dieses Phänomen wird in Java als „Upcasting“ bezeichnet), dann gibt der Typ des Objekts an, welche Methode oder Funktionalität aufgerufen wird. Diese Entscheidung wird während der Laufzeit von der JVM nach der Kompilierung des Codes getroffen. Daher wird es als Laufzeitpolymorphismus bezeichnet.

Es wird auch als „Dynamischer Methodenversand“ bezeichnet. Der Grund für diese Bezeichnung liegt darin, dass die Funktionalität der Methode dynamisch zur Laufzeit gemäß dem Objekt durch JVM entschieden wird

Es wird auch „späte Bindung“ genannt, da die Bindung von Methode und Objekt, d. h. die Funktionalität der Methode des Objekts, die angezeigt wird, spät, d. h. nach der Kompilierung, entschieden wird.

Regeln undEinschränkungen inRuntime Polymorphismus

Im Folgenden sind einige Regeln und Einschränkungen des Laufzeitpolymorphismus aufgeführt:

Regeln des Laufzeitpolymorphismus

• Methoden der untergeordneten und übergeordneten Klasse müssen denselben Namen haben.
• Methoden der untergeordneten und übergeordneten Klasse müssen denselben Parameter haben.
• IS-A-Beziehung ist obligatorisch (Vererbung).

Einschränkungen des Laufzeitpolymorphismus

• Man kann die privaten Methoden einer übergeordneten Klasse nicht überschreiben.
• Endgültige Methoden können nicht überschrieben werden.
• Statische Methoden können nicht überschrieben werden.

Beispiele für Laufzeitpolymorphismus in Java

 Wir werden hier einige Codebeispiele für Laufzeitpolymorphismus diskutieren.

Beispiel Nr. 1

In diesem Beispiel zeigen wir, wie die Methode Showcase() unterschiedliche Meldungen anzeigt, je nachdem, mit welchem ​​Objekttyp sie verknüpft ist. Wenn es mit dem Typ „Eltern“ verknüpft ist, werden Nachrichten von einer übergeordneten Klasse angezeigt. Wenn es mit dem Typ „Kinder“ verknüpft ist, werden Nachrichten aus der untergeordneten Klasse angezeigt.

Code:

class Parents {
public void showcase () {
System.out.println("I am Parent");
}
}
class Children extends Parents {
@Override
public void showcase () {
System.out.println("I am Children");
}
}
public class RunTimePolymorphism {
public static void main(String args[]) {
Parents superObject = new Parents();
superObject.showcase(); //method of super class or parent class is called
Parents subObject = new Children(); // upcasting
subObject.showcase();//method of sub class or child class is called by Parent reference, this is called "Run time Polymorphism"
Children subObject2 = new Children();
subObject2.showcase(); //method of sub class or child class is called
}
}

Ausgabe:

Beispiel Nr. 2

Nehmen wir ein Beispiel für Laufzeitpolymorphismus im Fall einer mehrstufigen Vererbung. In diesem Beispiel haben wir zwei Vererbungsebenen berücksichtigt. In diesem Beispiel zeigen wir, wie die Methode sip() unterschiedliche Meldungen anzeigt, je nachdem, mit welchem ​​Objekttyp sie verknüpft ist. Wenn es mit dem Typ „Mensch“ verknüpft ist, werden Nachrichten von einer übergeordneten Klasse angezeigt. Wenn es mit dem Typ „Man“ verknüpft ist, zeigt es Nachrichten von seiner untergeordneten Klasse an. Auch in der zweiten Vererbungsebene zeigt es bei Verknüpfung mit dem Typ „Baby“ Nachrichten von seiner untergeordneten Klasse seiner übergeordneten Klasse, der „Man“-Klasse.

Code:

class Human{
void sip() {
System.out.println("Human is sipping");
}
}
class Man extends Human{
void sip(){
System.out.println("Man is sipping soup");
}
}
class Baby extends Man{
void sip(){
System.out.println("Baby is sipping milk");
}
}
public class RunTimePolymorphism {
public static void main(String args[]){
Human superObject=new Human();
Human subObject=new Man();  // // upcasting : first level of heritance
Human babyObject=new Baby();  // // upcasting : second level of heritance
superObject.sip();
subObject.sip();  //run time polymorphism happening in first level of heritance
babyObject.sip(); //run time polymorphism happening in second level of heritance
}
}

Ausgabe:

Beispiel Nr. 3

Nehmen wir ein weiteres Beispiel für Laufzeitpolymorphismus im Fall der mehrstufigen Vererbung. In diesem Beispiel werden drei Vererbungsebenen berücksichtigt. In diesem Beispiel zeigen wir, wie die Methode feature() unterschiedliche Features anzeigt, je nachdem, mit welchem ​​Objekttyp sie verknüpft ist. Wenn es mit dem Typ „Betriebssystem“ verknüpft ist, werden Meldungen einer übergeordneten Klasse angezeigt. Wenn es mit dem Typ „DOS“ verknüpft ist, zeigt es Nachrichten von seiner untergeordneten Klasse an. Auch in der zweiten Vererbungsebene zeigt es bei Zuordnung zum Typ „Windows“ Nachrichten von seiner untergeordneten Klasse seiner übergeordneten Klasse, der „DOS“-Klasse. Auch in der dritten Vererbungsebene zeigt es bei Zuordnung zum Typ „WindowsMobile“ Nachrichten von seiner untergeordneten Klasse seiner übergeordneten Klasse, der „Windows“-Klasse.

Code:

class OperatingSytem{
void feature() {
System.out.println("This is Operating Sytem");
}
}
class DOS extends OperatingSytem{
void feature(){
System.out.println("This is DOS");
}
}
class Windows extends DOS{
void feature(){
System.out.println("This is Windows");
}
}
class WindowsMobile extends Windows{
void feature(){
System.out.println("This is Windows Mobile");
}
}
public class RunTimePolymorphism {
public static void main(String args[]){
OperatingSytem superObject=new OperatingSytem();
OperatingSytem subObject=new DOS();  // child object type : first level of heritance
OperatingSytem sub2Object=new Windows();  // child object type : second level of heritance
OperatingSytem sub3Object=new WindowsMobile();  // child object type : third level of heritance
superObject.feature();
subObject.feature();  //run time polymorphism happening in first level of heritance
sub2Object.feature(); //run time polymorphism happening in second level of heritance
sub3Object.feature(); //run time polymorphism happening in third level of heritance
}
}

Output:

Conclusion

This concludes our learning of the topic “Runtime Polymorphism in Java”. Write yourself the codes mentioned in the above examples in the java compiler and verify the output. Learning of codes will be incomplete if you will not write code by yourself.

Das obige ist der detaillierte Inhalt vonLaufzeitpolymorphismus in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!