Metodeoverstyring i Java

Hei! Du bruker allerede Java-metoder og vet mye om dem. Du har sannsynligvis stått overfor situasjonen der en klasse har mange metoder med samme navn, men forskjellige parametere. Du husker at i disse tilfellene brukte vi metodeoverbelastning. I dag vurderer vi en annen situasjon. Tenk deg at vi har en enkelt delt metode, men den må gjøre forskjellige ting i forskjellige klasser. Hvordan implementerer vi denne atferden? For å forstå, la oss vurdere en dyreforeldreklasse , som representerer dyr, og vi lager en talemetode i den:

public class Animal {

   public void speak() {

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

Selv om vi nettopp har begynt å skrive programmet, ser du sannsynligvis et potensielt problem: det er mange dyr i verden, og de "snakker" alle annerledes: katter mjauer, ender kvaksalver og slanger hveser. Målet vårt er enkelt: unngå å lage mange talemetoder. I stedet for å lage en catSpeak()- metode for mjauing, en snakeSpeak()- metode for hvesing osv., ønsker vi å kalle speak()metoden og få slangen til å hvese, katten mjau og hunden bjeffe. Vi kan enkelt oppnå dette ved å bruke metodeoverstyring. Wikipedia gir følgende forklaring av begrepet 'overstyring': Metodeoverstyring, i objektorientert programmering, er en språkfunksjon som lar en underklasse eller barneklasse gi en spesifikk implementering av en metode som allerede er levert av en av dens superklasser eller foreldreklasser Det er i hovedsak riktig. Metodeoverstyring lar deg ta en metode fra overordnet klasse og skrive din egen implementering i hver barneklasse. Den nye implementeringen 'erstatter' foreldrenes implementering i barneklassen. La oss se hvordan dette ser ut i et eksempel. Lag 4 klasser som arver dyreklassen vår :

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

"Her er et lite livhack for fremtiden: for å overstyre foreldreklassens metoder, gå til barneklassens kode i IntelliJ IDE, klikk Ctrl+O, og velg "Overstyr metoder..." i menyen. Bli vant til å bruke hurtigtaster fra begynnelsen — det vil hjelpe deg å skrive programmer raskere! For å spesifisere atferden vi trenger, gjorde vi et par ting:

1. I hver barneklasse laget vi en metode med samme navn som overordnet klasses metode.


2. Vi fortalte kompilatoren at det ikke var en tilfeldighet å navngi metoden på samme måte som i foreldreklassen: vi vil overstyre oppførselen. For å kommunisere dette til kompilatoren setter vi @Override-kommentaren over metoden.
   Når den plasseres over en metode, informerer @Override-kommentaren kompilatoren (så vel som programmerere som leser koden din): 'Alt er i orden. Dette er ikke en feil. Jeg er ikke glemsom. Jeg er klar over at en slik metode allerede eksisterer, og jeg ønsker å overstyre den.


3. Vi skrev implementeringen vi trenger for hver barneklasse. Når speak()- metoden kalles, skal en slange hvese, en bjørn skal knurre osv.

La oss se hvordan dette fungerer i et 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();
   }
}

Konsoll utgang:

Woof!
Meow!
Growl!
Hiss!

Utmerket! Alt fungerer som det skal! Vi opprettet 4 referansevariabler som lagrer objekter fra dyrenes overordnede klasse, og vi tildelte forekomster av 4 forskjellige barneklasser til dem. Som et resultat viser hvert objekt sin egen oppførsel. For hver barneklasse erstattet den overstyrte speak() -metoden 'native' speak()- metoden i Animal- klassen (som ganske enkelt viser 'Hei!'). Overstyring har flere begrensninger:

1. Den overstyrte metoden må ha samme parametere som den overordnede metoden.

   Hvis den overordnede klassens speak- metode har en String- parameter, må den overstyrte metoden i barneklassen også ha en String- parameter. Ellers vil kompilatoren generere en feil:

   
   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 overstyrte metoden må ha samme returtype som den overordnede metoden.

   Ellers får vi en kompilatorfeil:

   
   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. Tilgangsmodifikatoren på den overstyrte metoden må også være den samme som den "originale" 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!");
          }
   }
   

Metodeoverstyring i Java er en måte å implementere polymorfisme (prinsippet for OOP som vi beskrev i forrige leksjon). Dette betyr at hovedfordelen er den samme fleksibiliteten som vi diskuterte tidligere. Vi kan bygge et enkelt og logisk system av klasser, som hver har en spesifikk atferd (hunder bjeffer, katter mjauer), med et felles grensesnitt – en enkelt speak()-metode for dem alle i stedet for mange metoder, f.eks. dogSpeak() , speakCat () osv.