Riscrittura del Metodo Java

In questo tutorial, impareremo a sovrascrivere i metodi nei linguaggi di programmazione Java attraverso esempi.

Nel tutorial precedente, abbiamo imparato l'ereditarietà. L'ereditarietà è una proprietà dell'OOP che ci permette di derivare una nuova classe (sottoclasse) da una classe esistente (superclasse), in modo che la sottoclasse erediti le proprietà e i metodi della superclasse.

Se si definisce lo stesso metodo sia nella superclasse che nella sottoclasse, il metodo della sottoclasse sovrascriverà il metodo della superclasse. Questo si chiama sovrascrittura del metodo (o sovrascrittura di metodo).

Esempio 1: Sovrascrittura di metodo

class Animal {
　　　public void displayInfo() {
　　　　　　System.out.println("Sono un animale.");
　　　}
}
class Dog extends Animal {
　　　@Override
　　　public void displayInfo() {
　　　　　　System.out.println("Sono un cane.");
　　　}
}
class Main {}}
　　　public static void main(String[] args) {
　　　　　　Dog d1 = new Dog();
　　　　　　d1.displayInfo();
　　　}
}

Output:

Io sono un cane.

Nel programma sopra, il metodo displayInfo() esiste contemporaneamente nella superclasse Animal e nella sottoclasse Dog.

Quando chiamiamo il metodo displayInfo() utilizzando l'oggetto d1 (un oggetto della sottoclasse Dog), viene chiamato il metodo della sottoclasse Dog. Il metodo displayInfo() della sottoclasse sovrascrive il metodo dello stesso nome della superclasse.

Attenzione, nel nostro esempio abbiamo utilizzato il commento @Override. Nei linguaggi di programmazione Java, i commenti sono usati per fornire meta-dati al compilatore. In questo caso, il commento @Override informa il compilatore che il metodo dopo il commento sovrascriverà il metodo della superclasse.

L'uso di @Override non è obbligatorio. Tuttavia, quando usiamo questo metodo, dovrebbe seguire tutte le regole di copertura. Altrimenti, il compilatore genererà un errore.

Regole dell'override di Java

• La superclasse e la sottoclasse devono avere lo stesso nome del metodo, lo stesso tipo di ritorno e la stessa lista di parametri.

• Non possiamo sovrascrivere i metodi dichiarati come final e static.

• Dovremmo sempre sovrascrivere i metodi astratti della superclasse (che verranno discussi in un tutorial successivo).

Chiave super nell'override di Java

Un problema comune che si verifica durante l'esecuzione dell'override in Java è:

　Possiamo accedere ai metodi della superclasse dopo la sovrascrittura?

La risposta èAffermativo. Per accedere ai metodi della superclasse dal figlio, usiamo la chiave super.

Esempio 2: Utilizzo della chiave super

class Animal {
　　　public void displayInfo() {
　　　　　　System.out.println("Sono un animale.");
　　　}
}
class Dog extends Animal {
　　　public void displayInfo() {
　　　　　　super.displayInfo();
　　　　　　System.out.println("Sono un cane.");
　　　}
}
class Main {}}
　　　public static void main(String[] args) {
　　　　　　Dog d1 = new Dog();
　　　　　　d1.displayInfo();
　　　}
}

Output:

Sono un animale.
Io sono un cane.

Nell'esempio sopra, la sottoclasse Dog ha sovrascritto il metodo displayInfo() della superclasse Animal.

Quando utilizziamo l'oggetto d1 della sottoclasse Dog per chiamare il metodo displayInfo(), verrà chiamato il metodo interno della sottoclasse Dog. Non verrà chiamato il metodo interno del padre.

All'interno del metodo displayInfo() della sottoclasse Dog, abbiamo utilizzato super.displayInfo() per chiamare il metodo displayInfo() del padre.

Deve essere notato che i costruttori non vengono ereditati in Java. Pertanto, in Java non esistono problemi come la sovrascrittura dei costruttori.

Ma possiamo chiamare il costruttore del superclasse dal suo sottoinsieme. Per fare questo, usiamo super(). Per ulteriori informazioni, visitareChiave super di Java.

Specificatori di accesso nella sovrascrittura del metodo

Metodi dichiarati nello stesso metodo nel padre e nel figlio possono avere specificatori di accesso diversi. Ma c'è un limite.

Possiamo solo usare quei specificatori di accesso in un sottoinsieme di classi che forniscono una maggiore autorizzazione di accesso rispetto al padre. Ad esempio,

Supponiamo che il metodo myClass() del padre venga dichiarato come protected. Quindi, il metodo myClass() dello stesso nome nel figlio può essere public o protected, ma non può essere private.

Esempio 3: Specificatori di accesso nella sovrascrittura

class Animal {
　　　protected void displayInfo() {
　　　　　　System.out.println("Sono un animale.");
　　　}
}
class Dog extends Animal {
　　　public void displayInfo() {
　　　　　　System.out.println("Sono un cane.");
　　　}
}
class Main {}}
　　　public static void main(String[] args) {
　　　　　　Dog d1 = new Dog();
　　　　　　d1.displayInfo();
　　　}
}

Output:

Io sono un cane.

Nell'esempio sopra, la sottoclasse Dog sovrascrive il metodo displayInfo() della superclasse Animal.

Ogni volta che utilizziamo d1 (un oggetto della sottoclasse) per chiamare displayInfo(), viene chiamato il metodo interno della sottoclasse.

Attenzione, displayInfo() è dichiarato come protetto (protected) nel padre Animal. Il metodo ha un accesso pubblico (public) nel figlio Dog. Questo è permesso perché public fornisce un accesso più grande rispetto a protected.

Sovrascrittura di metodi astratti

In Java, le classi astratte vengono create come superclassi (classi base) di altre classi. E se una classe contiene metodi astratti, deve essere sovrascritta.

In seguito, impareremo di più sulle sovrascritture di classi astratte e metodi astratti.