Überschreibende Methoden

Hallo! Sie verwenden bereits Java-Methoden und wissen viel darüber. Sicherlich sind Sie auf eine Klasse mit vielen Methoden gestoßen, die den gleichen Namen, aber unterschiedliche Argumentlisten haben. Sie werden sich erinnern, dass wir in diesen Fällen Methodenüberladung verwendet haben. Heute schauen wir uns eine andere Situation an. Stellen Sie sich vor, dass wir eine gemeinsame Methode haben, diese jedoch abhängig von der Klasse, in der sie aufgerufen wird, unterschiedliche Dinge tun sollte. Wie implementieren wir dieses Verhalten? Um dies zu verstehen, nehmen wir die Animalübergeordnete Klasse, die Tiere darstellt, und erstellen speakdarin eine Methode:

public class Animal {
  
   public void speak() {

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

Obwohl wir gerade erst mit dem Schreiben unseres Programms begonnen haben, erkennen Sie wahrscheinlich ein potenzielles Problem: Die Welt ist voller Tiere, und alle „sprechen“ unterschiedlich: Katzen miauen, Enten quaken, Schlangen zischen usw. Unser Ziel ist einfach: wir Ich möchte vermeiden, eine Reihe von Methoden zum Sprechen zu entwickeln. Anstatt eine meow()Methode zum Miauen, hiss()Zischen usw. zu erstellen, möchten wir, dass die Schlange zischt, die Katze miaut und der Hund bellt, wenn die speak()Methode aufgerufen wird. Wir können dies leicht erreichen, indem wir die Methode überschreiben . Wikipedia erklärt den Begriff wie folgt: Methodenüberschreibungist in der objektorientierten Programmierung eine Sprachfunktion, die es einer Unterklasse oder untergeordneten Klasse ermöglicht, eine bestimmte Implementierung einer Methode bereitzustellen, die bereits von einer ihrer Oberklassen oder übergeordneten Klassen bereitgestellt wird. Das ist grundsätzlich richtig. Durch Überschreiben können Sie eine Methode einer übergeordneten Klasse übernehmen und in jeder abgeleiteten Klasse Ihre eigene Implementierung schreiben. Die neue Implementierung in der untergeordneten Klasse „ersetzt“ die in der übergeordneten Klasse. Sehen wir uns anhand eines Beispiels an, wie das aussieht. Lassen Sie uns 4 Nachkommen unserer AnimalKlasse erstellen:

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

Hier ist ein kleiner Lifehack für die Zukunft: Um die Methoden einer übergeordneten Klasse zu überschreiben, gehen Sie in der IntelliJ-IDE in den Code der abgeleiteten Klasse , 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. Sie werden das Codieren beschleunigen! Um das gewünschte Verhalten zu erhalten, haben wir einige Dinge getan:

1. In jeder Nachkommenklasse haben wir eine Methode mit demselben Namen wie die Methode in der Elternklasse erstellt.

2. Wir haben dem Compiler mitgeteilt, dass wir der Methode nicht einfach denselben Namen wie in der übergeordneten Klasse geben, sondern vielmehr ihr Verhalten überschreiben wollen. Diese „Nachricht“ an den Compiler wird über die Annotation @Override übermittelt .
   Die @Override-Annotation über einer Methode sagt dem Compiler (sowie anderen Programmierern, die Ihren Code lesen): „Keine Sorge. Das ist kein Fehler oder Versehen. Mir ist bewusst, dass diese Methode bereits existiert, und ich möchte sie überschreiben.“ .

3. Wir haben die Implementierung geschrieben, die wir für jede Nachkommenklasse benötigen. Wenn die speak()Methode aufgerufen wird, sollte eine Schlange zischen, ein Bär knurren und so weiter.

Mal sehen, wie das in einem 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.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

Konsolenausgabe:

Woof! 
Meow! 
Growl! 
Hiss!

Super, alles funktioniert wie es soll! Wir haben 4 Referenzvariablen erstellt, deren Typ die Animalübergeordnete Klasse ist, und ihnen 4 verschiedene Objekte der untergeordneten Klassen zugewiesen. Dadurch verhält sich jedes Objekt anders. Für jede der abgeleiteten Klassen speak()ersetzt die überschriebene Methode die vorhandene speak()Methode der AnimalKlasse (die einfach „Speaking:“ auf der Konsole anzeigt). Das Überschreiben von Methoden unterliegt mehreren Einschränkungen:

1. Eine überschriebene Methode muss dieselben Argumente haben wie die Methode in der übergeordneten Klasse.

   Wenn die speakMethode der übergeordneten Klasse a Stringals Eingabe akzeptiert, muss die überschriebene Methode in der untergeordneten Klasse auch a Stringals Eingabe akzeptieren. Andernfalls generiert der Compiler einen Fehler:

   
   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Speaking: " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          System.out.println("Meow!");
      }
   }
   




2. Die überschriebene Methode muss denselben Rückgabetyp haben wie die Methode in der übergeordneten Klasse.

   Andernfalls erhalten wir einen Kompilierungsfehler:

   
   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }
   




3. Auch der Zugriffsmodifikator der überschriebenen Methode darf nicht vom Original abweichen:

   
   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   public class Cat extends Animal {
   
      @Override
      private void speak() {      // Error!
          System.out.println("Meow!");
      }
   }
   

In Java ist das Überschreiben von Methoden eine Möglichkeit, Polymorphismus zu implementieren. Das bedeutet, dass sein Hauptvorteil in der Flexibilität liegt, über die wir zuvor gesprochen haben. Wir können eine einfache und logische Hierarchie von Klassen erstellen, jede mit spezifischem Verhalten (bellende Hunde, miauende Katzen), aber einer einzigen Schnittstelle – einer einzigen Methode speak()für alle statt einer Reihe verschiedener Methoden, z bark(). B. meow(), usw.