Menü

Java @override: Methodenüberschreibung und Laufzeitpolymorphismus

  • Haupt
  • Andere
  • Java @override: Methodenüberschreibung und Laufzeitpolymorphismus

java override method overriding

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem Tutorial wird anhand einfacher Beispiele erläutert, wie Sie mithilfe von Methodenüberschreibung und @ override-Annotation einen Laufzeitpolymorphismus in Java erzielen:

Wir haben das Polymorphismuskonzept und den Polymorphismus zur Kompilierungszeit bereits ausführlich erörtert. In diesem Tutorial werden wir uns mit dem Laufzeitpolymorphismus in Java befassen.

Im Gegensatz zum Polymorphismus zur Kompilierungszeit, bei dem der Methodenaufruf zur Kompilierungszeit aufgelöst wird, wird der Methodenaufruf beim Laufzeitpolymorphismus zur Laufzeit aufgelöst.

=> Überprüfen Sie ALLE Java-Tutorials hier.

@override_ Methode Überschreiben in Java

Was du lernen wirst:

Laufzeitpolymorphismus in Java

Ein Laufzeitpolymorphismus, der auch als bekannt ist dynamischer Polymorphismus oder Dynamischer Methodenversand ist ein Technik, bei der ein überschriebener Methodenaufruf zur Laufzeit dynamisch aufgelöst wird.

Der Laufzeitpolymorphismus in Java wird durch die Verwendung von „ Methode überschreiben ”. Das Überschreiben von Methoden ist eine Technik, mit der eine Methode in der übergeordneten Klasse in der untergeordneten Klasse neu definiert oder überschrieben wird.

Wenn die Methode in einer Klasse überschrieben wird, löst die dynamische Methodenversandtechnik den überschriebenen Methodenaufruf zur Laufzeit und nicht zur Kompilierungszeit auf.

Erreichen Sie Laufzeitpolymorphismus in Java - Methodenüberschreibung

Das Überschreiben von Methoden ist der Ansatz, mit dem wir einen Laufzeitpolymorphismus in Java erzielen. Wie bereits erwähnt, ist das Überschreiben von Methoden eine Technik, bei der die Unterklasse eine Methode hinzufügt, die bereits in ihrer übergeordneten Klasse vorhanden ist, und dieser Methode neue Funktionen hinzufügt. Dann sagen wir, dass die Basisklassenmethode überschrieben wird.

Die neue Methode, die wir in der Unterklasse mit demselben Prototyp wie die Methode der übergeordneten Klasse definiert haben, aber eine andere Implementierung hat, heißt „ übergeordnete Methode ” . Die Methode in der übergeordneten Klasse wird als „ Überschriebene Methode ”.

So starten Sie ein Projekt in Eclipse

Sobald die Methode überschrieben wurde, bleibt die Frage, wie der Aufruf dieser überschriebenen Methode gelöst wird.

Normalerweise rufen wir die überschriebene Methode über die Referenz der Basisklasse auf. Wir erstellen eine Referenz vom Typ base und weisen dann ein untergeordnetes Klassenobjekt mit dem neuen Schlüsselwort zu.

Somit hängt es vom Inhalt der Referenzvariablen ab oder davon, auf welches Objekt von der Basisklassenreferenz verwiesen wird, die bestimmt, welche Methode aufgerufen werden soll. Wenn die Referenzobjekte auf das Objekt der untergeordneten Klasse verweisen, wird die überschreibende Methode aufgerufen.

Andernfalls wird die überschriebene Methode aufgerufen, wenn das Referenzobjekt ein Basisklassenobjekt enthält. Ein Thema, das wir im Laufzeitpolymorphismus insbesondere für den dynamischen Methodenversand klarstellen müssen, ist „Upcasting“, das im Folgenden erläutert wird.

Upcasting

Wenn ein Referenzobjekt der übergeordneten Klasse, das wir oben besprochen haben, auf das Objekt der Unterklasse verweist oder auf dieses verweist, nennen wir es Upcasting.

Upcasting

Lassen Sie uns das Upcasting anhand eines einfachen Beispiels verstehen.

Beachten Sie, dass wir eine Klasse 'BaseClass' haben und diese BaseClass erweitern, um eine neue Klasse DerivedClass zu erstellen. Diese Struktur sieht wie unten gezeigt aus.

class BaseClass { ….//BaseClass code here } class DerivedClass extends BaseClass{ ….//DerivedClass code here }

Um Upcasting zu implementieren, deklarieren wir nun eine Referenzvariable vom Typ BaseClass. Als Nächstes weisen wir der Referenz der Klasse BaseClass ein Objekt von DerivedClass zu, wie in der folgenden Codeanweisung beschrieben.

BaseClass base = new DerivedClass (); //Upcasting

Hier können wir also sagen, dass wir das DerivedClass-Objekt in BaseClass übertragen haben. Für den Laufzeitpolymorphismus ist das Konzept des Upcasting sehr wichtig.

Upcasting ist daher im Allgemeinen der Vorgang, bei dem untergeordnete Objekte oder Unterklassenobjekte der Referenz eines Elternteils oder einer Oberklasse zugewiesen werden.

SuperClass reference = new Subclass Object;

Das folgende Java-Programm demonstriert das Überschreiben von Methoden und zeigt auch, wie Upcasting ausgeführt wird, um überschriebene Methodenaufrufe zur Laufzeit aufzulösen.

//base/parent class class Parent { void Print() //print method { System.out.println('Parent::Print() method'); } } //child class 1 inheriting from Parent class child1 extends Parent { void Print() //overridden print method { System.out.println('child1::Print() method'); } } //child class 2 inheriting from Parent class child2 extends Parent { void Print() //overridden print method { System.out.println('child2::Print() method'); } } class Main { public static void main(String() args) { Parent parent = new Parent(); parent.Print(); //executes parent Print () method parent = new child1(); //upcasting parent.Print(); //executes child1 Print () method parent = new child2(); //upcasting parent.Print(); //executes child2 Print () method

Ausgabe:

Upcasting - Ausgabe

Im obigen Programm haben wir zwei Klassen, d. H. Child1 und child2, die beide von einer 'Parent' -Klasse abgeleitet sind. Die übergeordnete Klasse verfügt über eine Methode 'Drucken', die sowohl in den Klassen child1 als auch child2 überschrieben wird. Anschließend erstellen wir in der Hauptmethode ein Referenzobjekt der übergeordneten Klasse mit dem Namen 'parent'.

Zuerst weisen wir ihm ein Objekt der Parent-Klasse zu und rufen dann die Methode „Print ()“ auf. Dann wiederholen wir dies, indem wir zuerst das child1-Objekt und dann das child2-Objekt der übergeordneten Referenz zuweisen.

Fragen und Antworten zum Interview mit mobilen Tests

Die Ausgabe zeigt abhängig vom Inhalt der übergeordneten Referenz, und die entsprechende Druckmethode wird aufgerufen.

Vorteile des dynamischen / Laufzeit-Polymorphismus

  • Bei dynamischem Polymorphismus kann der Programmierer Methoden überschreiben.
  • Es ermöglicht Klassen, eine Methode mit allgemeiner Implementierung zu definieren, die ihre Ableitungen dann überschreiben und die spezifische Implementierung bereitstellen können.
  • Beim dynamischen Methodenversand wird der Methodenaufruf zur Laufzeit aufgelöst, im Gegensatz zur Überladung, die zur Kompilierungszeit entschieden wird. Dies ermöglicht den Programmierern mehr Flexibilität.

Da der Laufzeitpolymorphismus die entsprechende Methode zur Laufzeit an den Aufruf bindet, rufen wir ihn auch auf dynamische Bindung oder späte Bindung . Der Polymorphismus zur Kompilierungszeit unterstützt dagegen statische Bindung oder frühe Bindung .

Statische vs. dynamische Bindung

Statische BindungDynamische Bindung
Der zur Kompilierungszeit aufgelöste Methodenaufruf ist eine statische Bindung.Der zur Laufzeit aufgelöste Methodenaufruf ist eine dynamische Bindung.
Das Überladen von Methoden ist ein Beispiel für statische Bindung.Das Überschreiben von Methoden ist ein Beispiel für eine dynamische Bindung.
Klassen- und Feldtypen werden für die statische Bindung verwendet.Objekte werden für die dynamische Bindung verwendet.
Private, endgültige und statische Entitäten verwenden statische Bindungen.Virtuelle Methoden verwenden dynamische Bindung.

Virtuelle Funktion / Methode In Java

Die virtuelle Funktion oder Methode in Java ist eine Funktion, die beim Laufzeitpolymorphismus verwendet wird. Im Gegensatz zu C ++ Java hat kein spezielles 'virtuelles' Schlüsselwort um anzuzeigen, dass eine Methode virtuell ist. Eine Methode, die in der Basisklasse definiert und in der abgeleiteten Klasse überschrieben wird, ist virtuell.

In Java ist standardmäßig jede nicht statische Methode außer privat und endgültig eine virtuelle Funktion. Beachten Sie daher, dass die oben diskutierten Methoden zum Implementieren des Laufzeitpolymorphismus ebenfalls virtuelle Methoden sind.

Da die statische Methode an Class gebunden ist und nicht mit einem Objekt aufgerufen werden kann, kann sie nicht mit Laufzeitpolymorphismus verwendet werden und ist auch keine virtuelle Funktion.

Schnittstellen in Java sind standardmäßig virtuell. Klassen, die Schnittstellen implementieren, stellen Implementierungen für die Schnittstellenmethoden bereit. Wie beim Laufzeitpolymorphismus wird auch der Aufruf von Schnittstellenmethoden zur Laufzeit aufgelöst.

Denken Sie daran, dass alle Schnittstellenmethoden virtuelle Funktionen sind, da Methoden in einer Schnittstelle so konzipiert sind, dass sie überschrieben werden.

Betrachten Sie beispielsweise den folgenden Code:

interface car{ void accelerate(); } class Maruti implements car{ void accelerate () { System.out.println(“Maruti car accelerated!!”); } }

Im obigen Code ist die Methode Accelerate () eine virtuelle Funktion, da sie Teil des Interface Car ist und überschrieben werden soll.

@override Annotation In Java

Die Annotation @override ist die Standardanmerkung in Java. Diese Anmerkung wurde in Java 1.5 eingeführt. Die Annotation @override wird verwendet, wenn die Unterklassenmethode ihre Oberklassenmethode überschreibt.

Durch die Verwendung der Annotation Java @override, um anzuzeigen, dass die Methode die übergeordnete Klassenmethode überschreibt, gibt ein Compiler eine Warnung aus, wenn die mit Annotationen versehene Methode nicht überschrieben wird. Daher muss die Methode überschrieben werden, wenn die Annotation @override verwendet wird.

Zweitens machen wir den Code mithilfe der Annotation @override besser lesbar. Wir können sofort erkennen, dass die deklarierte Methode überschrieben werden soll.

Die allgemeine Syntax der Java @ override-Annotation lautet

public @interface override

Das folgende Java-Programm zeigt die Verwendung der Annotation @override.

//base class definition class BaseClass { public void display() { System.out.println('BaseClass::display () method'); } } //derived class inheriting base class class DerivedClass extends BaseClass { @Override //indicates the display method being overridden public void display() { System.out.println('DerivedClass::display () method'); } } // main class public class Main { public static void main(String args()) { System.out.println('@Override Example'); //BaseClass type object;contain child object BaseClass testObj = new DerivedClass(); //call display method based on contents of object i.e. derived class display () testObj.display(); } }

Ausgabe:

@ Override Beispiel

Im obigen Programm haben wir eine BaseClass, die eine Anzeigemethode definiert. Dann leiten wir aus dieser BaseClass eine Klasse DerivedClass ab und markieren die Anzeigemethode mit der Annotation @override. Diese Methode wird in der DerivedClass überschrieben.

In der Hauptmethode erstellen wir eine BaseClass-Objektreferenz und verweisen sie auf das DerivedClass-Objekt, wodurch die Referenz die DerivedClass-Anzeigemethode aufruft.

Wenn wir die display () -Methode nicht in der Derived-Klasse implementiert hätten, hätte der Compiler eine Compiler-Warnung ausgegeben, da diese mit der Annotation @override gekennzeichnet ist.

Überladen und Überschreiben in Java

Nachdem wir sowohl das Überladen als auch das Überschreiben in Java erörtert haben, lassen Sie uns diese beiden Konzepte zusammenfassen.

Überladung hängt mit Polymorphismus zur Kompilierungszeit zusammen, d. H. Wir implementieren Polymorphismus zur Kompilierungszeit unter Verwendung von Überladung. Das Überladen erfolgt auf zwei Arten, d. H. Überladen von Methoden und Überladen von Bedienern.

Methodenüberladung ist die Technik, bei der wir mehr als eine Methode mit demselben Namen, aber unterschiedlichen Parameterlisten haben. Die Parameterliste wird anhand der Anzahl der Parameter, der Parametertypen oder der Reihenfolge der Parameter unterschieden.

Das Überladen von Operatoren in Java ist begrenzt und ermöglicht es uns, nur den Operator '+' zu überladen, mit dem zwei Zahlen hinzugefügt und zwei String-Objekte verkettet werden.

Das Überladen wird beim Kompilieren behoben und ist statisch. Es wird auch genannt ‘Frühzeitige Bindung’ .

Das Überschreiben von Methoden ist eine Funktion, mit der wir Laufzeitpolymorphismus implementieren. Beim Überschreiben von Methoden wird eine Methode der übergeordneten Klasse in der untergeordneten Klasse überschrieben. Dies bedeutet, dass der Methodenprototyp sowohl in der Super- als auch in der Unterklasse gleich bleibt, die Implementierungen jedoch unterschiedlich sind.

Das Überschreiben von Methoden verwendet die dynamische Methodenversandtechnik, um den Methodenaufruf aufzulösen und zu entscheiden, ob eine Oberklassen- oder Unterklassenmethode aufgerufen werden soll. Dies erfolgt zur Laufzeit.

Daher wird Laufzeitpolymorphismus auch als dynamischer Polymorphismus oder späte Bindung bezeichnet.

Lassen Sie uns als Nächstes die Unterschiede zwischen Überladen und Überschreiben in Java tabellarisch darstellen.

Überladen von Vs Überschreiben in Java

ÜberlastungÜberschreiben
Überladung wird beim Polymorphismus zur Kompilierungszeit verwendet.Das Überschreiben wird im Laufzeitpolymorphismus implementiert.
Kann in derselben Klasse durchgeführt werden. Kann oder kann nicht Vererbung erfordern.Das Überschreiben erfordert immer eine Vererbung.
Methoden werden mit demselben Methodennamen und unterschiedlicher Parameterliste überladen.Überschriebene Methoden haben dieselben Prototypen.
Der Rückgabetyp wird beim Überladen von Methoden nicht berücksichtigt.Der Rückgabetyp sollte bei überschriebenen und überschreibenden Methoden identisch sein.
Verbessert die Lesbarkeit des Programms.Das Überschreiben ermöglicht eine bestimmte Implementierungsklasse.

Häufig gestellte Fragen

F # 1) Können wir die statische Methode überschreiben?

Antworten: Nein. Statische Methoden können in Java nicht überschrieben werden. Dies liegt daran, dass statische Methoden klassenbasiert sind und von der Klasse direkt aufgerufen werden. Sie benötigen keine Objekte, die zur Laufzeit aufgerufen werden können. Daher wird der Versand der statischen Methode vom Compiler bestimmt.

F # 2) Können wir den Konstruktor überschreiben?

beste kostenlose Seiten, um Anime zu sehen

Antworten: Nein, wir können einen Konstruktor nicht überschreiben. Ein Konstruktor wird aufgerufen, wenn das Objekt erstellt wird. Es wird kein Objekt genannt. Eine der Anforderungen für das Überschreiben ist auch die überschriebene Methode, und die überschreibende Methode sollte dieselbe Methodensignatur haben, die bei Konstruktoren nicht möglich ist.

F # 3) Warum wird das Überschreiben von Methoden als dynamischer Polymorphismus bezeichnet?

Antworten: Beim Überschreiben von Methoden wird der Methodenaufruf zur Laufzeit dynamisch aufgelöst. Daher wird es dynamischer Polymorphismus genannt.

F # 4) Was ist die Verwendung von dynamischem Polymorphismus in Java?

Antworten: Der dynamische Polymorphismus verwendet eine dynamische Methodenversandtechnik, die das Überschreiben von Methoden unterstützt, sodass die Unterklasse eine spezifische Implementierung für die überschriebene Methode bereitstellen kann. Auf diese Weise können wir die spezifischen Funktionen implementieren, mit denen wir effiziente Programme schreiben können.

Zweitens müssen wir uns auch nicht um das Auflösen von Methodenaufrufen kümmern, da der dynamische Methodenversand entscheidet, welche Methode aufgerufen werden soll.

F # 5) Was ist der Unterschied zwischen statischer und dynamischer Bindung?

Antworten: Die Verknüpfung zwischen einem Methodenaufruf und seiner Implementierung wird als Bindung bezeichnet. Wenn diese Verknüpfung zur Kompilierungszeit aufgelöst wird, wird sie als statische Bindung bezeichnet. Wenn die Bindung zur Laufzeit dynamisch erfolgt, wird sie als dynamische Bindung bezeichnet.

Die statische Bindung verwendet den Datentyp der Klasse und Felder, um Methodenaufrufe aufzulösen. Die dynamische Bindung verwendet Objekte, um Methodenaufrufe aufzulösen. Statische Bindung wird auch als Polymorphismus zur Kompilierungszeit und dynamische Bindung auch als Laufzeitpolymorphismus bezeichnet.

Fazit

In diesem Tutorial haben wir den Laufzeitpolymorphismus in Java ausführlich erläutert.

Der Laufzeitpolymorphismus wird mithilfe der Methodenüberschreibung implementiert. Das Überschreiben von Methoden erfolgt in der Unterklasse, wobei eine in der Oberklasse definierte Methode in ihrer Unterklasse neu definiert oder überschrieben wird. Die Methodensignatur bleibt in der Super- und Unterklasse gleich.

Durch die Verwendung von Methodenüberschreibung können wir dieselbe Methode in der Unterklasse spezifisch implementieren. Auf diese Weise können wir effizientere Programme schreiben, die Vererbung beinhalten. Java bietet eine @ override-Annotation, um anzugeben, dass die Methode überschrieben werden soll.

Standardmäßig sind alle nicht statischen Methoden, die nicht endgültig sind, in Java virtuell. Alle virtuellen Methoden können überschrieben werden.

=> Sehen Sie sich hier die einfache Java-Schulungsreihe an.

Literatur-Empfehlungen

^