Metodöverstyrning i Java

Hej! Du använder redan Java-metoder och vet mycket om dem. Du har förmodligen ställts inför situationen där en klass har många metoder med samma namn men olika parametrar. Du kommer ihåg att i dessa fall använde vi metodöverbelastning. Idag överväger vi en annan situation. Föreställ dig att vi har en enda delad metod, men den måste göra olika saker i olika klasser. Hur implementerar vi detta beteende? För att förstå, låt oss överväga en djurförälderklass , som representerar djur, och vi kommer att skapa en talmetod i den:

public class Animal {

   public void speak() {

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

Även om vi precis har börjat skriva programmet ser du förmodligen ett potentiellt problem: det finns många djur i världen, och alla "talar" olika: katter jamar, ankor kvacksalvare och ormar väser. Vårt mål är enkelt: undvika att skapa mängder av talmetoder. Istället för att skapa en catSpeak() -metod för att jama, en snakeSpeak()- metod för väsning, etc., vill vi kalla speak()metod och få ormen att väsa, katten jama och hunden skälla. Vi kan enkelt uppnå detta genom att använda metodöverstyrning. Wikipedia ger följande förklaring av termen 'överstyrning': Metodöverstyrning, i objektorienterad programmering, är en språkfunktion som tillåter en underklass eller barnklass att tillhandahålla en specifik implementering av en metod som redan tillhandahålls av en av dess superklasser eller föräldraklasser Det är i huvudsak korrekt. Åsidosättande av metod låter dig ta någon metod från den överordnade klassen och skriva din egen implementering i varje underordnad klass. Den nya implementeringen 'ersätter' förälderns implementering i barnklassen. Låt oss se hur detta ser ut i ett exempel. Skapa 4 klasser som ärver vår djurklass :

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!");
   }
}

"Här är ett litet lifehack för framtiden: för att åsidosätta föräldraklassens metoder, gå till barnklassens kod i IntelliJ IDE, klicka på Ctrl+O och välj "Åsidosätt metoder..." i menyn. Vänja dig vid att använda snabbtangenter från början – det hjälper dig att skriva program snabbare! För att specificera det beteende vi behöver gjorde vi några saker:

1. I varje barnklass skapade vi en metod med samma namn som föräldraklassens metod.


2. Vi sa till kompilatorn att det inte var en tillfällighet att namnge metoden på samma sätt som i moderklassen: vi vill åsidosätta dess beteende. För att kommunicera detta till kompilatorn ställer vi in ​​@Override-kommentaren ovanför metoden.
   När den placeras ovanför en metod, informerar @Override-kommentaren kompilatorn (liksom programmerare som läser din kod): 'Allt är okej. Det här är inget misstag. Jag är inte glömsk. Jag är medveten om att en sådan metod redan finns och jag vill åsidosätta den.


3. Vi skrev implementeringen vi behöver för varje barnklass. När speak() -metoden anropas ska en orm fräsa, en björn morra osv.

Låt oss se hur detta fungerar i ett program:

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

Konsolutgång:

Woof!
Meow!
Growl!
Hiss!

Excellent! Allt fungerar som det ska! Vi skapade 4 referensvariabler som lagrar objekt från förälderklassen Animal och vi tilldelade instanser av 4 olika underordnade klasser till dem. Som ett resultat uppvisar varje objekt sitt eget beteende. För varje underordnad klass ersatte metoden för åsidosatt speak() metoden 'native' speak() i klassen Animal (som helt enkelt visar 'Hej!'). Åsidosättandet har flera begränsningar:

1. Den åsidosatta metoden måste ha samma parametrar som den överordnade metoden.

   Om den överordnade klassens speak -metod har en String- parameter, måste den åsidosatta metoden i den underordnade klassen också ha en String -parameter. Annars kommer kompilatorn att generera ett fel:

   
   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. Den åsidosatta metoden måste ha samma returtyp som den överordnade metoden.

   Annars får vi ett kompilatorfel:

   
   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. Åtkomstmodifieraren på den åsidosatta metoden måste också vara densamma som den "ursprungliga" metoden:

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

Metodöverstyrning i Java är ett sätt att implementera polymorfism (principen för OOP som vi beskrev i förra lektionen). Detta innebär att dess främsta fördel är samma flexibilitet som vi diskuterade tidigare. Vi kan bygga ett enkelt och logiskt system av klasser, som var och en har ett specifikt beteende (hundar skäller, katter jamar), med ett gemensamt gränssnitt - en enda speak()-metod för dem alla snarare än massor av metoder, t.ex. dogSpeak ( ) , speakCat () osv.