Methode negeren in Java

Hoi! U gebruikt al Java-methoden en weet er veel van. U hebt waarschijnlijk te maken gehad met de situatie waarin één klasse veel methoden heeft met dezelfde naam maar met verschillende parameters. U zult zich herinneren dat we in die gevallen method overloading gebruikten. Vandaag overwegen we een andere situatie. Stel je voor dat we één gedeelde methode hebben, maar dat deze verschillende dingen moet doen in verschillende klassen. Hoe passen we dit gedrag toe? Laten we, om dit te begrijpen, een Animal parent-klasse beschouwen, die dieren vertegenwoordigt, en we zullen er een spreekmethode in maken:

public class Animal {

   public void speak() {

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

Hoewel we nog maar net zijn begonnen met het schrijven van het programma, zie je waarschijnlijk een potentieel probleem: er zijn veel dieren in de wereld, en ze 'spreken' allemaal anders: katten miauwen, eenden kwaken en slangen sissen. Ons doel is eenvoudig: vermijd het creëren van massa's spreekmethoden. In plaats van een catSpeak()- methode te maken voor miauwen, een snakeSpeak()- methode voor sissen, enz., willen we de speak()-methode aanroepenmethode en laat de slang sissen, de kat miauwen en de hond blaffen. We kunnen dit eenvoudig bereiken door methode-overriding te gebruiken. Wikipedia geeft de volgende uitleg van de term 'overriding': Method overriding, in objectgeoriënteerd programmeren, is een taalfunctie waarmee een subklasse of onderliggende klasse een specifieke implementatie kan bieden van een methode die al wordt geleverd door een van zijn superklassen of ouderklassen Dat is in wezen juist. Met methode-overriding kunt u een methode van de bovenliggende klasse nemen en uw eigen implementatie in elke onderliggende klasse schrijven. De nieuwe implementatie 'vervangt' de implementatie van de ouder in de onderliggende klasse. Laten we eens kijken hoe dit er in een voorbeeld uitziet. Maak 4 klassen die onze klasse Animal erven :

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 is een kleine lifehack voor de toekomst: om de methoden van de bovenliggende klasse te overschrijven, ga naar de code van de onderliggende klasse in IntelliJ IDE, klik op Ctrl+O en kies "Overschrijf methoden..." in het menu. Wen aan het gebruik van sneltoetsen vanaf het begin - het zal je helpen sneller programma's te schrijven!Om het gedrag te specificeren dat we nodig hebben, hebben we een paar dingen gedaan:

1. In elke onderliggende klasse hebben we een methode gemaakt met dezelfde naam als de methode van de bovenliggende klasse.


2. We vertelden de compiler dat het geen toeval was om de methode dezelfde naam te geven als in de ouderklasse: we willen het gedrag ervan negeren. Om dit aan de compiler te communiceren, plaatsen we de @Override-annotatie boven de methode.
   Wanneer deze boven een methode wordt geplaatst, informeert de @Override-annotatie de compiler (evenals programmeurs die uw code lezen): 'Alles is in orde. Dit is geen vergissing. Ik ben niet vergeetachtig. Ik ben me ervan bewust dat zo'n methode al bestaat en ik wil die overschrijven'.


3. We schreven de implementatie die we nodig hebben voor elke kindklas. Wanneer de methode speak() wordt aangeroepen, hoort een slang te sissen, een beer te grommen, enz.

Laten we eens kijken hoe dit werkt in een programma:

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();
   }
}

Console-uitvoer:

Woof!
Meow!
Growl!
Hiss!

Uitstekend! Alles werkt zoals het hoort! We hebben 4 referentievariabelen gemaakt die objecten van de ouderklasse Animal opslaan, en we hebben er instanties van 4 verschillende onderliggende klassen aan toegewezen. Hierdoor vertoont elk object zijn eigen gedrag. Voor elke onderliggende klasse verving de overschreven methode speak() de methode 'native' speak() in de klasse Animal (die eenvoudigweg 'Hallo!' weergeeft). Overschrijven heeft verschillende beperkingen:

1. De overschreven methode moet dezelfde parameters hebben als de bovenliggende methode.

   Als de speak- methode van de bovenliggende klasse een String- parameter heeft , moet de overschreven methode in de onderliggende klasse ook een String- parameter hebben. Anders genereert de compiler een fout:

   
   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. De overschreven methode moet hetzelfde retourtype hebben als de bovenliggende methode.

   Anders krijgen we een compilerfout:

   
   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. De toegangsmodificator op de overschreven methode moet ook dezelfde zijn als de 'originele' methode:

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

Methode-overriding in Java is een manier om polymorfisme te implementeren (het principe van OOP dat we in de vorige les hebben beschreven). Dit betekent dat het belangrijkste voordeel dezelfde flexibiliteit is die we eerder hebben besproken. We kunnen een eenvoudig en logisch systeem van klassen bouwen, elk met een specifiek gedrag (honden blaffen, katten miauwen), met een gemeenschappelijke interface — een enkele speak()- methode voor allemaal in plaats van heel veel methoden, bijv. dogSpeak() , speakCat () , enz.