Meccanismo di override del metodo o Override in Java

Ciao! Utilizzi già i metodi in Java e ne sai molto. Probabilmente hai riscontrato una situazione in cui in una classe erano presenti molti metodi con lo stesso nome ma argomenti diversi. Se ricordi, in quei casi utilizzavamo il meccanismo di sovraccarico del metodo. Oggi esaminiamo una situazione diversa. Immagina di avere un metodo comune, ma che dovrebbe fare cose diverse a seconda della classe su cui è stato chiamato. Come implementare questo comportamento? Per capirlo, prendiamo una classe genitore Animalche denota animali e creiamo un metodo al suo interno voice: " voce ":

public class Animal {

   public void voice() {

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

Anche se abbiamo appena iniziato a scrivere il programma, molto probabilmente puoi vedere il potenziale problema: ci sono molti animali nel mondo e tutti “parlano” in modo diverso: i gatti miagolano, le anatre starnazzano, i serpenti sibilano. Il nostro obiettivo è semplice: evitare di creare una serie di metodi per esprimere un voto. Invece di creare metodi voiceCat()per miagolare, voiceSnake()sibilare, ecc., vogliamo che voice()il serpente sibili, il gatto miagoli e il cane abbai quando viene chiamato il metodo. Possiamo facilmente ottenere questo risultato utilizzando il meccanismo di override del metodo (Override in Java) . Wikipedia fornisce la seguente spiegazione del termine “overriding”: L’ overriding del metodo nella programmazione orientata agli oggetti è una delle caratteristiche di un linguaggio di programmazione che consente a una sottoclasse o classe figlia di fornire un’implementazione specifica di un metodo già implementato in una delle superclassi o classi madri. In generale è corretto. L'override ti consente di prendere un metodo di una classe genitore e scrivere la tua implementazione di questo metodo in ciascuna classe discendente. La nuova implementazione "sostituirà" il genitore nella classe figlia. Vediamo come appare con un esempio. Creiamo 4 classi successori per la nostra classe Animal:

public class Bear extends Animal {
   @Override
   public void voice() {
       System.out.println("Р-р-р!");
   }
}
public class Cat extends Animal {

   @Override
   public void voice() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void voice() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void voice() {
       System.out.println("Ш-ш-ш!");
   }
}

Un piccolo trucchetto per il futuro: per sovrascrivere i metodi della classe genitore, vai al codice della classe discendente in Intellij IDE a, premi Ctrl+O e seleziona “ Override metodi... ” dal menu. Abituati a usare i tasti di scelta rapida fin dall'inizio, velocizzerà la scrittura dei programmi! Per impostare il comportamento che volevamo, abbiamo fatto alcune cose:

1. Abbiamo creato un metodo in ciascuna classe discendente con lo stesso nome del metodo nella classe genitore.

2. Abbiamo detto al compilatore che abbiamo chiamato il metodo come nella classe genitore per un motivo: volevamo sovrascriverne il comportamento. Per questo "messaggio" al compilatore, inseriamo un'annotazione @Override sul metodo .
   L'annotazione @Override posta sopra un metodo dice al compilatore (e anche ai programmatori che leggono il tuo codice): “Va tutto bene, non è un errore o una mia dimenticanza. Ricordo che tale metodo esiste già e voglio sovrascriverlo."

3. Abbiamo scritto l'implementazione di cui avevamo bisogno per ogni classe discendente. Quando viene chiamato, un serpente voice()dovrebbe sibilare, un orso dovrebbe ringhiare, ecc.

Vediamo come funzionerà nel 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.voice();
       animal2.voice();
       animal3.voice();
       animal4.voice();
   }
}

Uscita console: Bau! Miao! Rrrr! Shhh! Ottimo, tutto funziona come dovrebbe! Abbiamo creato 4 variabili di riferimento della classe genitore Animale le abbiamo assegnate a 4 oggetti diversi delle classi discendenti. Di conseguenza, ogni oggetto si comporta in modo diverso. Per ciascuna delle classi discendenti, il metodo sovrascritto voice()ha sostituito il metodo "nativo" voice()della classe Animal(che invia semplicemente "Voice!" alla console). L'override presenta una serie di limitazioni:

1. Il metodo sottoposto a override deve avere gli stessi argomenti del metodo genitore.

   Se un metodo voicein una classe genitore accetta come input String, anche il metodo sottoposto a override nella classe figlia deve accettare come input String, altrimenti il ​​compilatore genererà un errore:

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




2. Il metodo sottoposto a override deve avere lo stesso tipo restituito del metodo padre.

   Altrimenti riceveremo un errore di compilazione:

   public class Animal {
   
      public void voice() {
   
          System.out.println("Voice!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String voice() {         //error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }




3. Anche il modificatore di accesso di un metodo sottoposto a override non può differire da quello “originale”:

   public class Animal {
   
      public void voice() {
   
          System.out.println("Voice!");
      }
   }
   
   public class Cat extends Animal {
   
      @Override
      private void voice() {      //error!
          System.out.println("Meow!");
      }
   }

Il metodo overriding in Java è uno degli strumenti per implementare l'idea del polimorfismo (il principio dell'OOP, di cui abbiamo parlato nell'ultima lezione). Pertanto, il vantaggio principale del suo utilizzo sarà la stessa flessibilità di cui abbiamo parlato prima. Possiamo costruire un sistema di classi semplice e logico, ognuna delle quali avrà un comportamento specifico (i cani abbaiano, i gatti miagolano), ma con un'unica interfaccia: un metodo voice()per tutti invece di un mucchio di metodi voiceDog(), voiceCat()ecc.