@Überschreiben in Java

1. Unterschied zwischen Überschreiben und Überladen in Java
2. Die @Override-Annotation in Java

In diesem Handbuch werden wir tief in das Thema Overriden und die Annotation @override in Java eintauchen. Überschreiben ist das Konzept, bei dem eine untergeordnete Klasse dieselbe Methode wie ihre übergeordnete Klasse hat. Dieses Konzept ist ein Beispiel für Laufzeitpolymorphismus.

Unterschied zwischen Überschreiben und Überladen in Java

Überschreiben wird oft mit einem anderen ähnlichen Begriff namens Überladung verwechselt. Bevor wir fortfahren, sehen wir uns die signifikanten Unterschiede zwischen ihnen in der folgenden Tabelle an.

Die @Override-Annotation in Java

Die Annotation @Override teilt dem Java-Compiler mit, dass wir eine Methode der Oberklasse überschreiben wollen. Obwohl es unnötig ist, @Override zu verwenden, wenn wir es in einen Prozess implementieren möchten, empfehlen wir es, es zu verwenden, da wir beim Erstellen der Methoden Fehler machen können. Beispielsweise können wir in der untergeordneten Klasse verschiedene Parameter bereitstellen, wodurch sie überladen statt überschrieben wird.

Um den Fehler zu beheben, verwenden wir @Override über dem Methodennamen in den untergeordneten Klassen, die dem Compiler mitteilen, dass wir die Methode überschreiben wollen. Wenn wir einen Fehler machen, gibt der Compiler einen Fehler aus.

Im folgenden Beispiel haben wir vier Klassen. In der Klasse OverrideJava befindet sich die Methode main() und dort werden die Methoden anderer Klassen mit ihren Objekten aufgerufen. Dann haben wir drei weitere Klassen, in denen die FirstClass eine Methode namens method1() mit einer Drucknachricht enthält. Schließlich erweitert die Klasse SecondClass die Klasse FirstClass, die das Konzept der Vererbung verwendet. Hier verwenden wir denselben Methodennamen und dieselbe Signatur method1() wie seine Elternklasse wie FirstClass.

Beachten Sie, dass wir in der Klasse SecondClass die Annotation @Override verwenden. Als nächstes erweitern wir die SecondClass in der ThirdClass-Klasse und verwenden die Methode method1() mit der Annotation. Um zu überprüfen, welche Methode aufgerufen wird, erstellen wir ein Objekt von ThirdClass, welches die untergeordnete Klasse ist, und rufen method1() auf. In der Ausgabe beobachten wir, dass die Methode innerhalb von ThirdClass aufgerufen wird, weil das Kind die innere Implementierung nach dem Elternteil geändert hat.

public class OverrideJava {
  public static void main(String[] args) {
    ThirdClass thirdClass = new ThirdClass();
    thirdClass.method1();
  }
}

class ThirdClass extends SecondClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Third Class");
  }
}

class SecondClass extends FirstClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Second Class");
  }
}

class FirstClass {
  void method1() {
    System.out.println("This is method1");
  }
}

Ausgabe:

Overriding method1 in Third Class

Wenn wir statt der Kindklasse die method1() der Elternklasse aufrufen wollen, können wir super.method1() verwenden, das die method1() ihrer Superklasse aufruft. Die Ausgabe zeigt, dass innerhalb von ThirdClass zuerst die übergeordnete Klasse, die Methode der SecondClass, aufgerufen wird, dann wird ihre eigene Implementierung aufgerufen.

public class OverrideJava {
  public static void main(String[] args) {
    ThirdClass thirdClass = new ThirdClass();
    thirdClass.method1();
  }
}

class ThirdClass extends SecondClass {
  @Override
  void method1() {
    super.method1();
    System.out.println("Overriding method1 in Third Class");
  }
}

class SecondClass extends FirstClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Second Class");
  }
}

class FirstClass {
  void method1() {
    System.out.println("This is method1");
  }
}

Ausgabe:

Overriding method1 in Second Class
Overriding method1 in Third Class