Einführung in den Laufzeitpolymorphismus in Java
In diesem Artikel lernen wir den Laufzeitpolymorphismus in Java kennen. "Poly" bedeutet "viele" und "Morph" bedeutet "Typ". Der Begriff Polymorphismus bezeichnet also dasselbe von verschiedenen Arten. Hier sehen wir, wie Java den Polymorphismus in der Laufzeit archiviert, dh nach dem Kompilieren, aber vor dem Ausführen des Codes.
Syntax:
Für den Laufzeit-Polymorphismus in Java sollten Sie die grundlegende Syntax von Java mit Anmerkungen befolgen. @Override Annotation kann hier verwendet werden, um speziell darauf hinzuweisen, welche Methode überschrieben werden soll.
Wie funktioniert Runtime Polymorphism in Java?
Der Laufzeitpolymorphismus funktioniert in Java durch Überschreiben von Methoden. Das Überschreiben von Methoden tritt auf, wenn Objekte denselben Methodennamen und dieselben Argumente und denselben Typ wie die übergeordnete Klasse haben, aber unterschiedliche Funktionen haben. Wenn eine untergeordnete Klasse diese Art von Methode enthält, nennen wir sie eine überschriebene Methode.
Warum heißt es Runtime Polymorphism?
Wenn wir eine überschriebene Methode einer untergeordneten Klasse über ihre übergeordnete Typreferenz aufrufen (dieses Phänomen in Java wird als "Upcasting" bezeichnet), gibt der Typ des Objekts an, welche Methode oder Funktionalität aufgerufen wird. Diese Entscheidung wird zur Laufzeit von JVM nach der Kompilierung des Codes getroffen. Daher wird es als Laufzeitpolymorphismus bezeichnet.
Es wird auch als "Dynamic Method Dispatch" bezeichnet. Der Grund dafür ist, dass die Funktionalität der Methode in der Laufzeit dynamisch gemäß dem Objekt von JVM festgelegt wird
Dies wird auch als "späte Bindung" bezeichnet, da die Bindung von Methode und Objekt, dh die Funktionalität, deren Methode angezeigt wird, erst spät, dh nach dem Kompilieren, entschieden wird.
Regeln und Einschränkungen im Runtim- und Polymorphismus
Im Folgenden sind einige der Regeln und Einschränkungen des Laufzeitpolymorphismus aufgeführt:
Regeln des Laufzeitpolymorphismus
- Methoden der Kind- und Elternklasse müssen den gleichen Namen haben.
- Methoden der Kind- und Elternklasse müssen den gleichen Parameter haben.
- IS-A-Beziehung ist obligatorisch (Vererbung).
Einschränkungen des Laufzeitpolymorphismus
- Private Methoden einer Elternklasse können nicht überschrieben werden.
- Man kann Final-Methoden nicht überschreiben.
- Man kann statische Methoden nicht überschreiben.
Beispiele für den Laufzeitpolymorphismus in Java
Wir werden hier einige Codebeispiele des Laufzeitpolymorphismus diskutieren.
Beispiel 1
In diesem Beispiel wird gezeigt, wie die Methode showcase () unterschiedliche Meldungen anzeigt, je nachdem, welchem Objekttyp sie zugeordnet ist. Wenn es dem Typ "Parents" zugeordnet ist, werden Nachrichten von der übergeordneten Klasse angezeigt. Wenn es dem Typ "Children" zugeordnet ist, werden Nachrichten von untergeordneten Klassen 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 # 2
Nehmen wir ein Beispiel für den Laufzeit-Polymorphismus bei mehrstufiger Vererbung. In diesem Beispiel haben wir zwei Vererbungsebenen berücksichtigt. In diesem Beispiel wird gezeigt, wie die Methode sip () unterschiedliche Meldungen anzeigt, je nachdem, welchem Objekttyp sie zugeordnet ist. Wenn es dem Typ "Human" zugeordnet ist, werden Nachrichten von einer übergeordneten Klasse angezeigt. Wenn es dem Typ "Man" zugeordnet ist, werden Nachrichten aus seiner untergeordneten Klasse angezeigt. Auch in der zweiten Vererbungsebene werden, wenn sie dem Typ "Baby" zugeordnet ist, Nachrichten von der untergeordneten Klasse der übergeordneten Klasse "Man" angezeigt.
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 # 3
Nehmen wir ein weiteres Beispiel für den Laufzeit-Polymorphismus bei mehrstufiger Vererbung. In diesem Beispiel haben wir drei Vererbungsebenen berücksichtigt. In diesem Beispiel wird gezeigt, wie die Methode feature () unterschiedliche Features anzeigt, je nachdem, welchem Objekttyp sie zugeordnet ist. Wenn es dem Typ "Betriebssystem" zugeordnet ist, werden Nachrichten von einer übergeordneten Klasse angezeigt. Wenn es dem Typ "DOS" zugeordnet ist, werden Nachrichten aus seiner untergeordneten Klasse angezeigt. Auch in der zweiten Vererbungsebene werden, wenn es dem Typ "Windows" zugeordnet ist, Nachrichten aus der untergeordneten Klasse des übergeordneten Typs angezeigt, bei dem es sich um die DOS-Klasse handelt. Auch in der dritten Vererbungsebene werden, wenn sie dem Typ "WindowsMobile" zugeordnet ist, Nachrichten von der untergeordneten Klasse der übergeordneten Klasse "Windows" angezeigt.
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
)
)
Ausgabe:
Fazit
Damit ist das Erlernen des Themas „Laufzeitpolymorphismus in Java“ abgeschlossen. Schreiben Sie sich die in den obigen Beispielen genannten Codes in den Java-Compiler und überprüfen Sie die Ausgabe. Das Erlernen von Codes ist unvollständig, wenn Sie den Code nicht selbst schreiben.
Empfohlene Artikel
Dies war eine Anleitung zum Laufzeit-Polymorphismus in Java. Hier diskutieren wir anhand von Beispielen, wie Runtime Polymorphism in Java funktioniert. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren -
- Statisches Schlüsselwort in Java
- In Java überschreiben
- Was ist Polymorphismus?
- Rust gegen Golang