Java @Override

Die @Override-Annotation wird verwendet, wenn ein Entwickler eine Funktion in Java überschreibt, um denselben Funktionsnamen zu verwenden, diesen Funktionen jedoch unterschiedliche Eigenschaften zuzuweisen. Wenn Ihnen Overrise-Funktionen in Java bekannt sind, Sie aber die Annotation @override nicht verwendet haben, da Sie keine Lust hatten, sie als obligatorische Option zum expliziten Schreiben zu verwenden. Es ist seit der Einführung von Java 1.5 standardmäßig aktiviert. Es fördert den Laufzeitpolymorphismus. Dies liegt daran, dass wir jede Funktion überschreiben können, ohne Annotationen zu verwenden. Dennoch hat es einen großen Vorteil: Wenn der Compiler versehentlich das Überschreiben übersieht (z. B. wenn der Entwickler einen Schreibfehler im Namen der überschreibenden Funktion gemacht hat). Mit Hilfe der überschreibenden Annotation versteht der Compiler die Basisfunktion und überschreibt sie mit der untergeordneten Funktion. Es verbessert auch die Lesbarkeit des Codes und reduziert den Wartungszeit- und -aufwand.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax:

public @interface Override

Vor dem Überschreibungsschlüsselwort sollte das Zeichen „@“ stehen, damit der Compiler erkennen kann, ob es sich um eine Annotation handelt oder nicht. Die Override-Funktion sollte sowohl in der Basisklasse als auch in der geerbten Klasse dieselbe Definition sowie einen Rückgabetyp und eine Reihe von Parametern haben. Sollte es einen Unterschied zwischen diesen geben, wird es nicht als Überschreibungsfunktion betrachtet, während diese Funktion als neue Funktion betrachtet wird.

Wie funktioniert @Override Annotation in Java?

• Override-Annotation wird direkt vor der in der geerbten Klasse definierten überschreibenden Funktion verwendet, um sicherzustellen, dass der Compiler versteht, dass diese Funktion absichtlich mit denselben Parametern und demselben Rückgabetyp in zwei verschiedenen Klassen definiert ist.
• Damit das System versteht, welche Funktion aufgerufen werden muss, da die Funktion sowohl in der Basisklasse als auch in der geerbten Klasse dieselben Parameter hat, müssen wir die Funktion mithilfe von Instanzen aufrufen.
• Wenn eine Funktion unter Verwendung des Objekts einer übergeordneten Klasse aufgerufen wird, wird die Funktion der übergeordneten Klasse mit ihrer lokalen Funktionsdefinition aufgerufen. Wenn das Objekt einer geerbten Klasse verwendet wird, wird die Funktion einer geerbten Klasse aufgerufen.

Beispiel:

Base class {}
Child class{}
Base object1= new Base();// Here Base class is instantiated so the function definition will be called from base class.
Base object2= new Child(); /// Here Child class is instantiated so the
function definition will be called from child class

• Jetzt werden die oben definierten Objekte mit den Namen „Objekt1“ und „Objekt2“ zusammen mit dem Punktoperator verwendet, um die Funktionsdefinition aufzurufen.
• Alle diese Funktionen funktionieren nur, wenn sie in der Hauptklasse verwaltet werden, von der aus die eigentliche Ausführung des Codes beginnt.
• Das Steuerelement greift auf die Hauptklasse zu und sucht dann nach Objektinstanzen der über der Hauptklasse vordefinierten Klassen.
• Das Objekt ruft dann die aufgerufene Funktion auf.
• Man kann auch gewünschte Parameter in der Funktion übergeben, wenn diese bereits in der Klassendefinition als Prototyp definiert sind.
• Eine Basisklasse kann von mehr als einer Klasse geerbt werden; Der einzige Unterschied besteht in der Objekterstellung und dem Funktionsaufruf mithilfe dieses Objekts.

Beispiele für Java @Override

Im Folgenden finden Sie Beispiele:

Beispiel #1

Ein Beispiel zur Veranschaulichung der Funktionsweise der Override-Annotation.

Erklärung:

Im folgenden Programm sind zwei Klassen definiert: Eine ist die Basisklasse, die auch als übergeordnete Klasse „Pclass“ bezeichnet wird, während die andere Klasse „Cclass“ die Eigenschaften und Mitgliedsfunktionen der Basis erbt wird als geerbte oder untergeordnete Klasse bezeichnet. Die Funktion wird zunächst in der übergeordneten Klasse deklariert. In diesem Beispiel lautet der Funktionsname printfunction(), der die Aufgabe zugewiesen wird, die als Parameter übergebene Zeichenfolge zu drucken.

Eine Funktion mit demselben Namen wird in einer geerbten Klasse namens „Cclass“ mit der vorangehenden @override-Annotation deklariert und definiert. Als Parameter wird eine andere Zeichenfolge übergeben. In der Hauptklasse werden die oben definierten Klassen durch die Erstellung ihrer Objekte instanziiert. „object1“ identifiziert das Objekt von Pclass und „object2“ identifiziert das Objekt für Cclass. Die gleiche Funktion wird mit diesen unterschiedlichen Objekten aufgerufen. Im ersten Fall erhält Objekt1 die Zeichenfolge von Pclass, der übergeordneten Klasse. Wenn später „object2“ aufgerufen wird, wird die Annotation „@override“ aktiviert und ändert die Inhaltszeichenfolge. Dies ist eine übergeordnete Funktion, die unter Java für verständlichen Code und bessere Funktionalität bereitgestellt wird.

Code:

// This is Base class
class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// Thi is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
public class Main {
public static void main(String[] args)
{
Pclass object1 = new Pclass();
object1.printfunction();
Pclass object2 = new Cclass();
object2.printfunction();
}
}

Ausgabe:

Hier ist der Ausgabebildschirm mit zwei Zeichenfolgen. Die erste Zeichenfolgenzeile stammt von der Basisfunktion, während die zweite Zeichenfolgenzeile von der überschreibenden Funktion stammt, die in der geerbten Klasse definiert ist.

Example #2

Here we have one base class with two child classes inheriting it. The second inherited class is instantiated, and the output string is triggered from the 2^nd inherited class.

Code:

class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// This is Child class
class Cclass2 extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class number 2 \"Cclass\".");
}
}
// This is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
public class Main {
public static void main(String[] args)
{
Pclass object1 = new Pclass();
object1.printfunction();
Pclass object2 = new Cclass2();
object2.printfunction();
}
}

Output:

Conclusion

Hence Java override function comes with a lot of benefits like providing run-time polymorphism, easy code access, clean code and many more. Adding override annotation assures that the compiler understands the intention of function definition via function declarations in classes. This is one of the important properties of the oops concept called polymorphism.

Das obige ist der detaillierte Inhalt vonJava @Override. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!