Methodenüberschreibung in Java

Hallo! Sie verwenden bereits Java-Methoden und wissen viel darüber. Sie sind wahrscheinlich schon einmal mit der Situation konfrontiert, dass eine Klasse viele Methoden mit demselben Namen, aber unterschiedlichen Parametern hat. Sie werden sich erinnern, dass wir in diesen Fällen Methodenüberladung verwendet haben. Heute denken wir über eine andere Situation nach. Stellen Sie sich vor, wir haben eine einzige gemeinsam genutzte Methode, die jedoch in verschiedenen Klassen unterschiedliche Aufgaben ausführen muss. Wie setzen wir dieses Verhalten um? Zum Verständnis betrachten wir eine übergeordnete Klasse „Animal“ , die Tiere darstellt, und erstellen darin eine Speak- Methode:

public class Animal {

   public void speak() {

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

Obwohl wir gerade erst mit dem Schreiben des Programms begonnen haben, sehen Sie wahrscheinlich ein potenzielles Problem: Es gibt viele Tiere auf der Welt, und alle „sprechen“ unterschiedlich: Katzen miauen, Enten quaken und Schlangen zischen. Unser Ziel ist einfach: Vermeiden Sie die Entwicklung vieler Sprechmethoden. Anstatt eine catSpeak()- Methode zum Miauen, eine SnakeSpeak()- Methode zum Zischen usw. zu erstellen, möchten wir speak() aufrufenMethode und lassen Sie die Schlange zischen, die Katze miauen und den Hund bellen. Wir können dies leicht durch Methodenüberschreibung erreichen. Wikipedia erklärt den Begriff „Überschreiben“ wie folgt: „Methodenüberschreiben“ ist 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 bereitgestellt wird Elternklassen Das ist im Wesentlichen richtig. Durch das Überschreiben von Methoden können Sie eine Methode der übergeordneten Klasse verwenden und in jeder untergeordneten Klasse eine eigene Implementierung schreiben. Die neue Implementierung „ersetzt“ die Implementierung der übergeordneten Klasse in der untergeordneten Klasse. Sehen wir uns an einem Beispiel an, wie das aussieht. Erstellen Sie 4 Klassen, die unsere Animal- Klasse erben :

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 der übergeordneten Klasse zu überschreiben, gehen Sie zum Code der untergeordneten Klasse in der IntelliJ-IDE, klicken Sie auf Strg+O und wählen Sie im Menü „Methoden überschreiben …“. Gewöhnen Sie sich an die Verwendung von Hotkeys von Anfang an – es wird Ihnen helfen, Programme schneller zu schreiben! Um das Verhalten zu spezifizieren, das wir brauchen, haben wir ein paar Dinge getan:

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


2. Wir haben dem Compiler gesagt, dass es kein Zufall ist, dass die Methode denselben Namen wie in der übergeordneten Klasse hat: Wir wollen ihr Verhalten überschreiben. Um dies dem Compiler mitzuteilen, setzen wir die Annotation @Override über der Methode.
   Wenn die Annotation @Override über einer Methode platziert wird, informiert sie den Compiler (sowie Programmierer, die Ihren Code lesen): „Alles ist in Ordnung.“ Das ist kein Fehler. Ich bin nicht vergesslich. Mir ist bewusst, dass eine solche Methode bereits existiert, und ich möchte sie überschreiben.


3. Wir haben die Implementierung geschrieben, die wir für jede untergeordnete Klasse benötigen. Wenn die speak()- Methode aufgerufen wird, sollte eine Schlange zischen, ein Bär knurren usw.

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!

Exzellent! Alles funktioniert wie es soll! Wir haben vier Referenzvariablen erstellt, die Objekte der übergeordneten Klasse „Animal“ speichern , und ihnen Instanzen von vier verschiedenen untergeordneten Klassen zugewiesen. Dadurch zeigt jedes Objekt sein eigenes Verhalten. Für jede untergeordnete Klasse ersetzte die überschriebene speak()- Methode die „native“ speak()- Methode in der Animal- Klasse (die einfach „Hallo!“ anzeigt). Das Überschreiben hat mehrere Einschränkungen:

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

   Wenn die Speak- Methode der übergeordneten Klasse über einen String- Parameter verfügt, muss die überschriebene Methode in der untergeordneten Klasse ebenfalls über einen String- Parameter verfügen. Andernfalls generiert der Compiler einen Fehler:

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




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

   Andernfalls erhalten wir einen Compilerfehler:

   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. Der Zugriffsmodifikator für die überschriebene Methode muss ebenfalls mit der „ursprünglichen“ Methode identisch sein:

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

Das Überschreiben von Methoden in Java ist eine Möglichkeit, Polymorphismus zu implementieren (das Prinzip von OOP, das wir in der letzten Lektion beschrieben haben). Das bedeutet, dass sein Hauptvorteil die gleiche Flexibilität ist, die wir zuvor besprochen haben. Wir können ein einfaches und logisches System von Klassen erstellen, von denen jede ein bestimmtes Verhalten hat (Hunde bellen, Katzen miauen), mit einer gemeinsamen Schnittstelle – einer einzigen speak()-Methode für alle statt einer Unmenge von Methoden, z. B. dogSpeak() , speakCat () usw.