Metode tilsidesætter

Hej! Du bruger allerede Java-metoder og ved meget om dem. Du er helt sikkert stødt på en klasse med mange metoder, der har samme navn, men forskellige argumentlister. Du vil huske, at vi i disse tilfælde brugte metodeoverbelastning. I dag tager vi et kig på en anden situation. Forestil dig, at vi har én fælles metode, men den skal gøre forskellige ting alt efter hvilken klasse den kaldes i. Hvordan implementerer vi denne adfærd? For at forstå dette, lad os tage Animalforældreklassen, som repræsenterer dyr, og skabe en speakmetode i den:

public class Animal {
  
   public void speak() {

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

Selvom vi lige er begyndt at skrive vores program, kan du sikkert se et potentielt problem: Verden er fuld af masser af dyr, og de "taler" alle forskelligt: ​​katte miaver, ænder kvaksalver, slanger hvæser osv. Vores mål er enkelt: vi ønsker at undgå at skabe en masse metoder til at tale. I stedet for at skabe en meow()metode til at mjave, hiss()til hvæsende osv., ønsker vi, at slangen hvæser, katten mjaver, og hunden gøer, når metoden speak()kaldes. Vi kan nemt opnå dette ved at bruge metodetilsidesættelse . Wikipedia forklarer udtrykket som følger: Metode tilsidesætter, i objektorienteret programmering, er en sprogfunktion, der tillader en underklasse eller underklasse at levere en specifik implementering af en metode, der allerede er leveret af en af ​​dens superklasser eller overordnede klasser. Det er grundlæggende rigtigt. Tilsidesættelse giver dig mulighed for at tage en metode fra en overordnet klasse og skrive din egen implementering i hver afledt klasse. Den nye implementering i børneklassen "erstatter" den i forælderen. Lad os se, hvordan det ser ud med et eksempel. Lad os skabe 4 efterkommere af vores Animalklasse:

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 lille lifehack for fremtiden: for at tilsidesætte metoderne for en overordnet klasse, gå ind i koden for den afledte klasse i IntelliJ IDE , tryk på Ctrl+O og vælg Tilsidesæt metoder... fra menuen. Væn dig til at bruge genvejstaster fra starten. De vil fremskynde kodning! For at få den ønskede adfærd gjorde vi et par ting:

1. I hver efterkommerklasse oprettede vi en metode med samme navn som metoden i den overordnede klasse.

2. Vi fortalte compileren, at vi ikke bare giver metoden det samme navn som i den overordnede klasse, men snarere vil vi tilsidesætte dens adfærd. Denne "besked" til compileren formidles via @Override- annotationen.
   @Override-annotationen over en metode fortæller compileren (såvel som andre programmører, der læser din kode), "Bare rolig. Dette er ikke en fejl eller forglemmelse. Jeg er klar over, at denne metode allerede eksisterer, og jeg vil gerne tilsidesætte den. .

3. Vi skrev den implementering, vi skal bruge for hver efterkommerklasse. Når speak()metoden kaldes, skal en slange hvæse, en bjørn knurre og så videre.

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

Konsoludgang:

Woof! 
Meow! 
Growl! 
Hiss!

Super, alt fungerer som det skal! Vi oprettede 4 referencevariabler, hvis type er den Animaloverordnede klasse, og tildelte dem 4 forskellige objekter af efterkommerklasserne. Som et resultat opfører hvert objekt sig forskelligt. For hver af de afledte klasser erstatter den tilsidesatte metode klassens speak()eksisterende metode (som blot viser "Speaking: " på konsollen). Metodetilsidesættelse har flere begrænsninger: speak()Animal

1. En tilsidesat metode skal have de samme argumenter som metoden i den overordnede klasse.

   Hvis speakmetoden for den overordnede klasse tager a Stringsom input, så skal den overstyrede metode i efterkommerklassen også tage a Stringsom input. Ellers vil compileren generere en fejl:

   
   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. Den tilsidesatte metode skal have samme returtype som metoden i den overordnede klasse.

   Ellers får vi en kompileringsfejl:

   
   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. Den tilsidesatte metodes adgangsmodifikator kan heller ikke adskille sig fra den originale:

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

I Java er metodetilsidesættelse en måde at implementere polymorfi på. Det betyder, at dens største fordel er den fleksibilitet, som vi talte om tidligere. Vi kan opbygge et enkelt og logisk hierarki af klasser, hver med specifik adfærd (gøende hunde, mjauende katte) men en enkelt grænseflade - en enkelt speak()metode for alle i stedet for en masse forskellige metoder, f.eks bark(). meow(), osv.