Override del metodo in Java

CIAO! Stai già utilizzando i metodi Java e ne sai molto. Probabilmente hai affrontato la situazione in cui una classe ha molti metodi con lo stesso nome ma parametri diversi. Ricorderete che in quei casi abbiamo utilizzato l'overloading del metodo. Oggi consideriamo un'altra situazione. Immagina di avere un singolo metodo condiviso, ma deve fare cose diverse in classi diverse. Come implementiamo questo comportamento? Per capire, consideriamo una classe genitore Animal , che rappresenta gli animali, e creeremo un metodo speak in essa:

public class Animal {

   public void speak() {

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

Anche se abbiamo appena iniziato a scrivere il programma, probabilmente vedi un potenziale problema: ci sono molti animali nel mondo e tutti "parlano" in modo diverso: i gatti miagolano, le anatre cigolano e i serpenti sibilano. Il nostro obiettivo è semplice: evitare di creare un sacco di metodi di conversazione. Invece di creare un metodo catSpeak() per miagolare, un metodo snakeSpeak() per sibilare, ecc., vogliamo chiamare il metodo speak()metodo e fai sibilare il serpente, miagolare il gatto e abbaiare il cane. Possiamo facilmente raggiungere questo obiettivo usando l'override del metodo. Wikipedia fornisce la seguente spiegazione del termine 'override': l'override del metodo, nella programmazione orientata agli oggetti, è una caratteristica del linguaggio che consente a una sottoclasse o a una classe figlia di fornire un'implementazione specifica di un metodo che è già fornito da una delle sue superclassi o classi genitore Ciò è essenzialmente corretto. L'override del metodo ti consente di prendere un metodo della classe genitore e scrivere la tua implementazione in ogni classe figlia. La nuova implementazione "sostituisce" l'implementazione del genitore nella classe figlia. Vediamo come appare in un esempio. Crea 4 classi che ereditano la nostra classe Animal :

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

"Ecco un piccolo trucco per il futuro: per sovrascrivere i metodi della classe genitore, vai al codice della classe figlia in IntelliJ IDE, fai clic su Ctrl+O e scegli "Sostituisci metodi..." nel menu. Abituati a usare i tasti di scelta rapida fin dall'inizio — ti aiuterà a scrivere programmi più velocemente!Per specificare il comportamento di cui abbiamo bisogno, abbiamo fatto alcune cose:

1. In ogni classe figlia, abbiamo creato un metodo con lo stesso nome del metodo della classe genitore.


2. Abbiamo detto al compilatore che nominare il metodo come nella classe genitore non era un caso: vogliamo sovrascrivere il suo comportamento. Per comunicarlo al compilatore, impostiamo l'annotazione @Override sopra il metodo.
   Quando viene posizionata sopra un metodo, l'annotazione @Override informa il compilatore (così come i programmatori che leggono il tuo codice): 'Va tutto bene. Questo non è un errore. Non sono smemorato. Sono consapevole che tale metodo esiste già e voglio sovrascriverlo'.


3. Abbiamo scritto l'implementazione di cui abbiamo bisogno per ogni classe figlio. Quando viene chiamato il metodo speak() , un serpente dovrebbe sibilare, un orso dovrebbe ringhiare, ecc.

Vediamo come funziona in un 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();
   }
}

Uscita console:

Woof!
Meow!
Growl!
Hiss!

Eccellente! Tutto funziona come dovrebbe! Abbiamo creato 4 variabili di riferimento che memorizzano oggetti della classe genitore Animal e abbiamo assegnato loro istanze di 4 diverse classi figlie. Di conseguenza, ogni oggetto mostra il proprio comportamento. Per ogni classe figlio, il metodo speak() sovrascritto ha sostituito il metodo 'native' speak() nella classe Animal (che visualizza semplicemente 'Ciao!'). L'override ha diverse limitazioni:

1. Il metodo sottoposto a override deve avere gli stessi parametri del metodo padre.

   Se il metodo speak della classe genitore ha un parametro String , anche il metodo sovrascritto nella classe figlia deve avere un parametro String . In caso contrario, il compilatore genererà un errore:

   
   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. Il metodo sottoposto a override deve avere lo stesso tipo restituito del metodo padre.

   Altrimenti, otterremo un errore del compilatore:

   
   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. Anche il modificatore di accesso sul metodo sottoposto a override deve essere lo stesso del metodo "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!");
          }
   }
   

L'override del metodo in Java è un modo per implementare il polimorfismo (il principio di OOP che abbiamo descritto nell'ultima lezione). Ciò significa che il suo vantaggio principale è la stessa flessibilità di cui abbiamo discusso in precedenza. Possiamo costruire un sistema di classi semplice e logico, ognuna con un comportamento specifico (cani che abbaiano, gatti miagolano), con un'interfaccia comune — un unico metodo speak() per tutti piuttosto che un sacco di metodi, ad esempio dogSpeak() , speakCat () , ecc.