In questo tutorial, impareremo come sovrascrivere il metodo in Java con l'aiuto di esempi.
Nell'ultimo tutorial abbiamo appreso dell'ereditarietà. L'ereditarietà è una proprietà OOP che ci consente di derivare una nuova classe (sottoclasse) da una classe esistente (superclasse). La sottoclasse eredita gli attributi e i metodi della superclasse.
Ora, se lo stesso metodo è definito sia nella superclasse che nella sottoclasse, il metodo della classe della sottoclasse sovrascrive il metodo della superclasse. Questo è noto come override del metodo.
Esempio 1: sostituzione del metodo
class Animal ( public void displayInfo() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( @Override public void displayInfo() ( System.out.println("I am a dog."); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.displayInfo(); ) )
Uscita :
Io sono un cane.
Nel programma precedente, il displayInfo()metodo è presente sia nella superclasse Animal che nella sottoclasse Dog.
Quando chiamiamo displayInfo()usando l'oggetto d1 (oggetto della sottoclasse), viene chiamato il metodo all'interno della sottoclasse Dog. Il displayInfo()metodo della sottoclasse sovrascrive lo stesso metodo della superclasse.
Notare l'uso @Overridedell'annotazione nel nostro esempio. In Java, le annotazioni sono i metadati che abbiamo utilizzato per fornire informazioni al compilatore. Qui, l' @Overrideannotazione specifica al compilatore che il metodo dopo questa annotazione sovrascrive il metodo della superclasse.
Non è obbligatorio usare @Override. Tuttavia, quando lo usiamo, il metodo dovrebbe seguire tutte le regole di override. In caso contrario, il compilatore genererà un errore.
Regole di sostituzione Java
- Sia la superclasse che la sottoclasse devono avere lo stesso nome di metodo, lo stesso tipo restituito e lo stesso elenco di parametri.
- Non possiamo sovrascrivere il metodo dichiarato come
finalestatic. - Dovremmo sempre sovrascrivere i metodi astratti della superclasse (verranno discussi nei tutorial successivi).
super parola chiave in Java Override
Una domanda comune che sorge durante l'esecuzione dell'override in Java è:
Possiamo accedere al metodo della superclasse dopo l'override?
Ebbene, la risposta è sì . Per accedere al metodo della superclasse dalla sottoclasse, utilizziamo la superparola chiave.
Esempio 2: utilizzo di super parola chiave
class Animal ( public void displayInfo() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( public void displayInfo() ( super.displayInfo(); System.out.println("I am a dog."); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.displayInfo(); ) )
Uscita :
Io sono un animale Io sono un cane.
Nell'esempio sopra, la sottoclasse Dog sovrascrive il metodo displayInfo()della superclasse Animal.
Quando chiamiamo il metodo displayInfo()utilizzando l'oggetto d1 della sottoclasse Dog, viene chiamato il metodo all'interno della sottoclasse Dog; il metodo all'interno della superclasse non viene chiamato.
All'interno displayInfo()della sottoclasse Dog, abbiamo usato super.displayInfo()per chiamare displayInfo()la superclasse.
È importante notare che i costruttori in Java non vengono ereditati. Quindi, non esiste qualcosa come l'override del costruttore in Java.
Tuttavia, possiamo chiamare il costruttore della superclasse dalle sue sottoclassi. Per questo, usiamo super(). Per saperne di più, visita Java super keyword.
Specificatori di accesso nella sostituzione del metodo
Lo stesso metodo dichiarato nella superclasse e nelle sue sottoclassi può avere specificatori di accesso diversi. Tuttavia, c'è una restrizione.
Possiamo usare solo quegli specificatori di accesso in sottoclassi che forniscono un accesso maggiore rispetto allo specificatore di accesso della superclasse. Per esempio,
Supponiamo che myClass()venga dichiarato un metodo nella superclasse protected. Quindi, lo stesso metodo myClass()nella sottoclasse può essere publico protected, ma non private.
Esempio 3: specificatore di accesso in override
class Animal ( protected void displayInfo() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( public void displayInfo() ( System.out.println("I am a dog."); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.displayInfo(); ) )
Uscita :
Io sono un cane.
Nell'esempio sopra, la sottoclasse Dog sovrascrive il metodo displayInfo()della superclasse Animal.
Ogni volta che chiamiamo displayInfo()usando d1 (oggetto della sottoclasse), viene chiamato il metodo all'interno della sottoclasse.
Si noti che il displayInfo()è dichiarato protectednella superclasse Animal. Lo stesso metodo ha lo publicspecificatore di accesso nella sottoclasse Dog. Ciò è possibile perché publicfornisce un accesso più ampio rispetto a protected.
Override dei metodi astratti
In Java, le classi astratte vengono create per essere la superclasse di altre classi. E, se una classe contiene un metodo astratto, è obbligatorio sovrascriverlo.
Impareremo di più sulle classi astratte e sull'override dei metodi astratti nei tutorial successivi.
