@Override in Java

1. Differenza tra sovrascrittura e sovraccarico in Java
2. L’annotazione @Override in Java

In questa guida, approfondiremo l’argomento dell’override e dell’annotazione @override in Java. L’override è il concetto in cui una classe figlio ha lo stesso metodo della sua classe padre. Questo concetto è un esempio di polimorfismo di runtime.

Differenza tra sovrascrittura e sovraccarico in Java

L’override viene spesso confuso con un altro termine simile chiamato sovraccarico. Prima di andare oltre, vediamo le differenze significative tra loro nella tabella seguente.

L’annotazione @Override in Java

L’annotazione @Override dice al compilatore Java che vogliamo sovrascrivere un metodo dalla superclasse. Sebbene non sia necessario utilizzare @Override ogni volta che vogliamo implementarlo in un processo, consigliamo di utilizzarlo perché possiamo commettere errori durante la creazione dei metodi. Ad esempio, potremmo fornire parametri diversi nella classe figlio, il che rende l’overload anziché l’override.

Per superare l’errore, usiamo @Override sopra il nome del metodo nelle classi figlie che dice al compilatore che vogliamo sovrascrivere il metodo. Se commettiamo un errore, il compilatore genererà un errore.

Nell’esempio seguente, abbiamo quattro classi. La classe OverrideJava è dove si trova il metodo main() e dove verranno chiamati i metodi di altre classi utilizzando i loro oggetti. Poi abbiamo altre tre classi in cui la FirstClass ha un metodo chiamato method1() con dentro un messaggio di stampa. Infine, la classe SecondClass estende la FirstClass che utilizza il concetto di ereditarietà. Qui, usiamo lo stesso nome del metodo e la stessa firma method1() della sua classe genitore come FirstClass.

Si noti che nella classe SecondClass usiamo l’annotazione @Override. Successivamente, estendiamo la SecondClass nella classe ThirdClass e utilizziamo il metodo method1() con l’annotazione. Per verificare quale metodo viene chiamato, creiamo un oggetto di ThirdClass, che è la classe figlia, e chiamiamo method1(). Nell’output, osserviamo che il metodo all’interno di ThirdClass viene chiamato perché il figlio ha modificato l’implementazione interna dopo il genitore.

public class OverrideJava {
  public static void main(String[] args) {
    ThirdClass thirdClass = new ThirdClass();
    thirdClass.method1();
  }
}

class ThirdClass extends SecondClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Third Class");
  }
}

class SecondClass extends FirstClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Second Class");
  }
}

class FirstClass {
  void method1() {
    System.out.println("This is method1");
  }
}

Produzione:

Overriding method1 in Third Class

Se vogliamo chiamare method1() della classe genitore invece della classe figlia, possiamo usare super.method1() che chiama method1() della sua super classe. L’output mostra che all’interno di ThirdClass prima viene chiamata la sua classe genitore che è il metodo SecondClass, quindi viene chiamata la sua implementazione.

public class OverrideJava {
  public static void main(String[] args) {
    ThirdClass thirdClass = new ThirdClass();
    thirdClass.method1();
  }
}

class ThirdClass extends SecondClass {
  @Override
  void method1() {
    super.method1();
    System.out.println("Overriding method1 in Third Class");
  }
}

class SecondClass extends FirstClass {
  @Override
  void method1() {
    System.out.println("Overriding method1 in Second Class");
  }
}

class FirstClass {
  void method1() {
    System.out.println("This is method1");
  }
}

Produzione:

Overriding method1 in Second Class
Overriding method1 in Third Class