Methodenüberschreibungsmechanismus oder Override in Java

Hallo! Sie verwenden bereits Methoden in Java und wissen viel darüber. Sie sind wahrscheinlich auf eine Situation gestoßen, in der es in einer Klasse viele Methoden mit demselben Namen, aber unterschiedlichen Argumenten gab. Wie Sie sich erinnern, haben wir in diesen Fällen den Methodenüberladungsmechanismus verwendet. Schauen wir uns heute eine andere Situation an. Stellen Sie sich vor, wir haben eine gemeinsame Methode, die jedoch je nach aufgerufener Klasse unterschiedliche Aufgaben ausführen sollte. Wie implementiert man dieses Verhalten? Um es herauszufinden, nehmen wir eine übergeordnete Klasse, Animaldie Tiere bezeichnet, und erstellen darin eine Methode voice– „ voice “:

public class Animal {

   public void voice() {

       System.out.println("Stimme!");
   }
}

Obwohl wir gerade erst mit dem Schreiben des Programms begonnen haben, können Sie das potenzielle Problem höchstwahrscheinlich erkennen: Es gibt viele Tiere auf der Welt, und alle „sprechen“ unterschiedlich: Katzen miauen, Enten quaken, Schlangen zischen. Unser Ziel ist einfach: Vermeiden Sie die Entwicklung einer Reihe von Methoden zur Stimmabgabe. Anstatt Methoden voiceCat()zum Miauen, voiceSnake()Zischen usw. zu erstellen, möchten wir, voice()dass die Schlange zischt, die Katze miaut und der Hund bellt, wenn die Methode aufgerufen wird. Dies können wir leicht mit dem Methodenüberschreibungsmechanismus (Override in Java) erreichen . Wikipedia erklärt den Begriff „Überschreiben“ wie folgt: Das Überschreiben von Methoden in der objektorientierten Programmierung ist eine der Funktionen einer Programmiersprache, die es einer Unterklasse oder untergeordneten Klasse ermöglicht, eine spezifische Implementierung einer Methode bereitzustellen, die bereits in einer der Oberklassen implementiert ist oder übergeordnete Klassen. Im Großen und Ganzen ist es richtig. Durch Überschreiben können Sie eine Methode einer übergeordneten Klasse übernehmen und in jeder untergeordneten Klasse eine eigene Implementierung dieser Methode schreiben. Die neue Implementierung „ersetzt“ die übergeordnete Klasse in der untergeordneten Klasse. Sehen wir uns anhand eines Beispiels an, wie das aussieht. Erstellen wir 4 Nachfolgeklassen für unsere Klasse Animal:

public class Bear extends Animal {
   @Override
   public void voice() {
       System.out.println("Р-р-р!");
   }
}
public class Cat extends Animal {

   @Override
   public void voice() {
       System.out.println("Miau!");
   }
}

public class Dog extends Animal {

   @Override
   public void voice() {
       System.out.println("Schuss!");
   }
}


public class Snake extends Animal {

   @Override
   public void voice() {
       System.out.println("Ш-ш-ш!");
   }
}

Ein kleiner Life-Hack für die Zukunft: Um die Methoden der übergeordneten Klasse zu überschreiben, gehen Sie zum Code der untergeordneten Klasse in Intellij IDE a, drücken Sie Strg+O und wählen Sie „ Methoden überschreiben... “ aus dem Menü. Gewöhnen Sie sich von Anfang an an die Verwendung von Hotkeys, das beschleunigt das Schreiben von Programmen! Um das gewünschte Verhalten festzulegen, haben wir einige Dinge getan:

1. Wir haben in jeder untergeordneten Klasse eine Methode mit demselben Namen wie die Methode in der übergeordneten Klasse erstellt.

2. Wir haben dem Compiler mitgeteilt, dass wir die Methode aus einem bestimmten Grund genauso benannt haben wie in der übergeordneten Klasse: Wir wollten ihr Verhalten überschreiben. Für diese „Nachricht“ an den Compiler fügen wir der Methode eine @Override-Annotation hinzu .
   Die über einer Methode platzierte @Override-Annotation sagt dem Compiler (und auch Programmierern, die Ihren Code lesen): „Alles ist in Ordnung, das ist kein Fehler oder meine Vergesslichkeit.“ Ich erinnere mich, dass eine solche Methode bereits existiert, und ich möchte sie überschreiben.

3. Wir haben die Implementierung geschrieben, die wir für jede Nachkommenklasse benötigten. Wenn man ruft, sollte eine Schlange voice()zischen, ein Bär knurren usw.

Mal sehen, wie das im Programm funktioniert:

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.voice();
       animal2.voice();
       animal3.voice();
       animal4.voice();
   }
}

Konsolenausgabe: Wuff! Miau! Rrrr! Pssst! Super, alles funktioniert wie es soll! Wir haben 4 Referenzvariablen der übergeordneten Klasse erstellt Animalund sie 4 verschiedenen Objekten der untergeordneten Klassen zugewiesen. Dadurch verhält sich jedes Objekt anders. Für jede der Nachkommenklassen voice()ersetzte die überschriebene Methode die „native“ Methode voice()der Klasse Animal(die einfach „Voice!“ an die Konsole ausgibt). Das Überschreiben hat eine Reihe von Einschränkungen:

1. Die überschriebene Methode muss dieselben Argumente wie die übergeordnete Methode haben.

   Wenn eine Methode voicein einer übergeordneten Klasse als Eingabe akzeptiert String, muss die überschriebene Methode in der untergeordneten Klasse auch als Eingabe akzeptieren String, andernfalls gibt der Compiler einen Fehler aus:

   public class Animal {
   
      public void voice(String s) {
   
          System.out.println("Stimme! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override//Fehler!
      public void voice() {
          System.out.println("Miau!");
      }
   }




2. Die überschriebene Methode muss denselben Rückgabetyp wie die übergeordnete Methode haben.

   Andernfalls erhalten wir einen Kompilierungsfehler:

   public class Animal {
   
      public void voice() {
   
          System.out.println("Stimme!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String voice() {         //Fehler!
          System.out.println("Miau!");
          return "Miau!";
      }
   }




3. Auch der Zugriffsmodifikator einer überschriebenen Methode darf sich nicht vom „ursprünglichen“ unterscheiden:

   public class Animal {
   
      public void voice() {
   
          System.out.println("Stimme!");
      }
   }
   
   public class Cat extends Animal {
   
      @Override
      private void voice() {      //Fehler!
          System.out.println("Miau!");
      }
   }

Das Überschreiben von Methoden in Java ist eines der Werkzeuge zur Umsetzung der Idee des Polymorphismus (das Prinzip von OOP, über das wir in der letzten Vorlesung gesprochen haben). Daher wird der Hauptvorteil der Verwendung die gleiche Flexibilität sein, über die wir zuvor gesprochen haben. Wir können ein einfaches und logisches System von Klassen erstellen, von denen jede ein spezifisches Verhalten hat (Hunde bellen, Katzen miauen), aber mit einer einzigen Schnittstelle – einer Methode für voice()alle anstelle einer Reihe von Methoden voiceDog()usw.voiceCat()