
Animal
classe genitore, che rappresenta gli animali, e creiamo un
speak
metodo in essa:
public class Animal {
public void speak() {
System.out.println("Hello!");
}
}
Sebbene abbiamo appena iniziato a scrivere il nostro programma, probabilmente puoi vedere un potenziale problema: il mondo è pieno di molti animali, e tutti "parlano" in modo diverso: i gatti miagolano, le anatre cigolano, i serpenti sibilano, ecc. Il nostro obiettivo è semplice:

meow()
metodo per miagolare,
hiss()
per sibilare, ecc., vogliamo che il serpente sibili, il gatto miagoli e il cane abbai quando
speak()
viene chiamato il metodo. Possiamo facilmente ottenere questo risultato usando
l'override del metodo . Wikipedia spiega il termine come segue:
Override del metodo, nella programmazione orientata agli oggetti, è una funzionalità del linguaggio che consente a una sottoclasse o classe figlio di fornire un'implementazione specifica di un metodo che è già fornito da una delle sue superclassi o classi padre. Questo è fondamentalmente corretto. L'override ti consente di prendere un metodo di una classe genitore e scrivere la tua implementazione in ogni classe derivata. La nuova implementazione nella classe figlia "sostituisce" quella nella classe genitore. Vediamo come appare con un esempio. Creiamo 4 discendenti della nostra
Animal
classe:
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 eseguire l'override dei metodi di una classe genitore, vai nel codice della classe derivata in
IntelliJ IDE , premi
Ctrl+O e seleziona
Override methods... dal menu. Abituati a usare i tasti di scelta rapida fin dall'inizio. Accelereranno la codifica! Per ottenere il comportamento desiderato, abbiamo fatto alcune cose:
- In ogni classe discendente, abbiamo creato un metodo con lo stesso nome del metodo nella classe genitore.
-
Abbiamo detto al compilatore che non stiamo solo dando al metodo lo stesso nome della classe genitore, ma piuttosto vogliamo sovrascriverne il comportamento. Questo "messaggio" al compilatore viene trasmesso tramite l' annotazione @Override .
L'annotazione @Override sopra un metodo dice al compilatore (così come ad altri programmatori che leggono il tuo codice), "Non preoccuparti. Questo non è un errore o una svista. Sono consapevole che questo metodo esiste già e voglio sovrascriverlo . - Abbiamo scritto l'implementazione di cui abbiamo bisogno per ogni classe discendente. Quando
speak()
viene chiamato il metodo, un serpente dovrebbe sibilare, un orso dovrebbe ringhiare e così via.
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 della console:
Woof!
Meow!
Growl!
Hiss!
Ottimo, tutto funziona come dovrebbe! Abbiamo creato 4 variabili di riferimento il cui tipo è la
Animal
classe genitore e assegnato loro 4 diversi oggetti delle classi discendenti. Di conseguenza, ogni oggetto si comporta in modo diverso. Per ciascuna delle classi derivate, il
speak()
metodo sovrascritto sostituisce il
speak()
metodo esistente della
Animal
classe (che visualizza semplicemente "Speaking: " sulla console).

-
Un metodo sottoposto a override deve avere gli stessi argomenti del metodo nella classe padre.
Se il
speak
metodo della classe genitore accetta aString
come input, anche il metodo sovrascritto nella classe discendente deve accettare aString
come input. In caso contrario, il compilatore genererà un errore: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!"); } }
-
Il metodo sottoposto a override deve avere lo stesso tipo restituito del metodo nella classe padre.
Altrimenti, otterremo un errore di compilazione:
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!"; } }
-
Anche il modificatore di accesso del metodo sottoposto a override non può differire da quello 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!"); } }
speak()
per tutti piuttosto che una serie di metodi diversi, ad esempio
bark()
,
meow()
, ecc.
GO TO FULL VERSION