In Java, l'Overriding è una funzionalità che consente a una sottoclasse o classe figlia di fornire un'implementazione specifica di un metodo già fornito da una delle sue superclassi o classi madri. Quando un metodo in una sottoclasse ha lo stesso nome, gli stessi parametri o firma e lo stesso tipo restituito (o sottotipo) di un metodo nella sua superclasse, allora si dice che il metodo nella sottoclasse oltrepassare il metodo nella superclasse.
L'override del metodo è uno dei modi in cui Java ottiene risultati Polimorfismo in fase di esecuzione . La versione di un metodo eseguito sarà determinata dall'oggetto utilizzato per invocarlo. Se un oggetto di una classe genitore viene utilizzato per invocare il metodo, verrà eseguita la versione nella classe genitore, ma se viene utilizzato un oggetto della sottoclasse per invocare il metodo, verrà eseguita la versione nella classe figlia. In altre parole, è il tipo dell'oggetto a cui si fa riferimento (non il tipo della variabile di riferimento) che determina quale versione di un metodo sottoposto a override verrà eseguita.
Esempio di override del metodo in Java
Di seguito è riportata l'implementazione del metodo Java Overriding:
Giava
// Java program to demonstrate> // method overriding in java> // Base Class> class> Parent {> >void> show() { System.out.println(>'Parent's show()'>); }> }> // Inherited class> class> Child>extends> Parent {> >// This method overrides show() of Parent> >@Override> void> show()> >{> >System.out.println(>'Child's show()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >// If a Parent type reference refers> >// to a Parent object, then Parent's> >// show is called> >Parent obj1 =>new> Parent();> >obj1.show();> >// If a Parent type reference refers> >// to a Child object Child's show()> >// is called. This is called RUN TIME> >// POLYMORPHISM.> >Parent obj2 =>new> Child();> >obj2.show();> >}> }> |
>
>Produzione
Parent's show() Child's show()>
Regole per la sostituzione del metodo Java
1. Override e modificatori di accesso
IL modificatore di accesso poiché un metodo sottoposto a override può consentire un accesso maggiore, ma non inferiore, rispetto al metodo sottoposto a override. Ad esempio, un metodo di istanza protetto nella superclasse può essere reso pubblico, ma non privato, nella sottoclasse. Ciò genererà un errore in fase di compilazione.
Giava
// A Simple Java program to demonstrate> // Overriding and Access-Modifiers> class> Parent {> >// private methods are not overridden> >private> void> m1()> >{> >System.out.println(>'From parent m1()'>);> >}> >protected> void> m2()> >{> >System.out.println(>'From parent m2()'>);> >}> }> class> Child>extends> Parent {> >// new m1() method> >// unique to Child class> >private> void> m1()> >{> >System.out.println(>'From child m1()'>);> >}> >// overriding method> >// with more accessibility> >@Override> public> void> m2()> >{> >System.out.println(>'From child m2()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj1 =>new> Parent();> >obj1.m2();> >Parent obj2 =>new> Child();> >obj2.m2();> >}> }> |
>
>Produzione
From parent m2() From child m2()>
2. I metodi finali non possono essere sovrascritti
Se non vogliamo che un metodo venga sovrascritto, lo dichiariamo come finale . Perfavore guarda Utilizzo di Final con ereditarietà .
Giava
// A Java program to demonstrate that> // final methods cannot be overridden> class> Parent {> >// Can't be overridden> >final> void> show() {}> }> class> Child>extends> Parent {> >// This would produce error> >void> show() {}> }> |
>
>
Produzione
13: error: show() in Child cannot override show() in Parent void show() { } ^ overridden method is final> 3. I metodi statici non possono essere sovrascritti (sostituzione del metodo rispetto all'occultamento del metodo):
Quando definisci un metodo statico con la stessa firma di un metodo statico nella classe base, è noto come metodo nascosto . La tabella seguente riassume cosa succede quando definisci un metodo con la stessa firma di un metodo in una superclasse.
| Metodo dell'istanza della superclasse | Metodo statico delle superclassi | |
|---|---|---|
| Metodo dell'istanza della sottoclasse | Sostituisce | Genera un errore in fase di compilazione |
| Metodo statico della sottoclasse | Genera un errore in fase di compilazione | Nasconde |
Giava
// Java program to show that> // if the static method is redefined by> // a derived class, then it is not> // overriding, it is hiding> class> Parent {> >// Static method in base class> >// which will be hidden in subclass> >static> void> m1()> >{> >System.out.println(>'From parent '> >+>'static m1()'>);> >}> >// Non-static method which will> >// be overridden in derived class> >void> m2()> >{> >System.out.println(> >'From parent '> >+>'non - static(instance) m2() '>);> >}> }> class> Child>extends> Parent {> >// This method hides m1() in Parent> >static> void> m1()> >{> >System.out.println(>'From child static m1()'>);> >}> >// This method overrides m2() in Parent> >@Override> public> void> m2()> >{> >System.out.println(> >'From child '> >+>'non - static(instance) m2() '>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj1 =>new> Child();> >// As per overriding rules this> >// should call to class Child static> >// overridden method. Since static> >// method can not be overridden, it> >// calls Parent's m1()> >obj1.m1();> >// Here overriding works> >// and Child's m2() is called> >obj1.m2();> >}> }> |
>
>Produzione
From parent static m1() From child non - static(instance) m2()>
4. I metodi privati non possono essere sovrascritti
Metodi privati non possono essere sovrascritti poiché vengono collegati durante la fase di compilazione. Pertanto non possiamo nemmeno sovrascrivere i metodi privati in una sottoclasse. (Vedi Questo per dettagli).
Giava
class> SuperClass {> >private> void> privateMethod()> >{> >System.out.println(> >'This is a private method in SuperClass'>);> >}> >public> void> publicMethod()> >{> >System.out.println(> >'This is a public method in SuperClass'>);> >privateMethod();> >}> }> class> SubClass>extends> SuperClass {> >// This is a new method with the same name as the> >// private method in SuperClass> >private> void> privateMethod()> >{> >System.out.println(> >'This is a private method in SubClass'>);> >}> >// This method overrides the public method in SuperClass> >public> void> publicMethod()> >{> >System.out.println(> >'This is a public method in SubClass'>);> >privateMethod();>// calls the private method in> >// SubClass, not SuperClass> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >SuperClass obj1 =>new> SuperClass();> >obj1.publicMethod();>// calls the public method in> >// SuperClass> >SubClass obj2 =>new> SubClass();> >obj2.publicMethod();>// calls the overridden public> >// method in SubClass> >}> }> |
>
>Produzione
This is a public method in SuperClass This is a private method in SuperClass This is a public method in SubClass This is a private method in SubClass>
5. Il metodo di override deve avere lo stesso tipo restituito (o sottotipo)
Da Java 5.0 in poi è possibile avere diversi tipi restituiti per un metodo sovrascritto nella classe figlia, ma il tipo restituito del figlio dovrebbe essere un sottotipo del tipo restituito del genitore. Questo fenomeno è noto come tipo di rendimento covariante .
Giava
class> SuperClass {> >public> Object method()> >{> >System.out.println(> >'This is the method in SuperClass'>);> >return> new> Object();> >}> }> class> SubClass>extends> SuperClass {> >public> String method()> >{> >System.out.println(> >'This is the method in SubClass'>);> >return> 'Hello, World!'>;> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >SuperClass obj1 =>new> SuperClass();> >obj1.method();> >SubClass obj2 =>new> SubClass();> >obj2.method();> >}> }> |
>
>Produzione
This is the method in SuperClass This is the method in SubClass>
6. Invocazione del metodo sovrascritto dalla sottoclasse
Possiamo chiamare il metodo della classe genitore nel metodo di override utilizzando il metodo parola chiave eccellente .
Giava
// A Java program to demonstrate that overridden> // method can be called from sub-class> // Base Class> class> Parent {> >void> show() { System.out.println(>'Parent's show()'>); }> }> // Inherited class> class> Child>extends> Parent {> >// This method overrides show() of Parent> >@Override> void> show()> >{> >super>.show();> >System.out.println(>'Child's show()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj =>new> Child();> >obj.show();> >}> }> |
>
>Produzione
Parent's show() Child's show()>
Override e Costruttore
Non possiamo sovrascrivere il costruttore poiché la classe genitore e quella figlia non possono mai avere un costruttore con lo stesso nome (il nome del costruttore deve sempre essere lo stesso del nome della classe).
Override e gestione delle eccezioni
Di seguito sono riportate due regole da tenere presenti quando si esegue l'override dei metodi relativi alla gestione delle eccezioni.
Regola numero 1
Se il metodo sottoposto a override della superclasse non genera un'eccezione, il metodo sottoposto a override della sottoclasse può solo sollevare l'eccezione eccezione non controllata , lanciare un'eccezione controllata porterà a un errore in fase di compilazione.
Giava
// Java program to demonstrate overriding when> // superclass method does not declare an exception> class> Parent {> >void> m1() { System.out.println(>'From parent m1()'>); }> >void> m2() { System.out.println(>'From parent m2()'>); }> }> class> Child>extends> Parent {> >@Override> >// no issue while throwing unchecked exception> >void> m1()>throws> ArithmeticException> >{> >System.out.println(>'From child m1()'>);> >}> >@Override> >// compile-time error> >// issue while throwing checked exception> >void> m2()>throws> Exception> >{> >System.out.println(>'From child m2'>);> >}> }> |
>
>
Produzione
error: m2() in Child cannot override m2() in Parent void m2() throws Exception{ System.out.println('From child m2');} ^ overridden method does not throw Exception> Regola n.2
Se il metodo sottoposto a override della superclasse genera un'eccezione, il metodo di override della sottoclasse può lanciare solo la stessa eccezione della sottoclasse. Lanciare eccezioni genitore nel file Gerarchia delle eccezioni porterà a un errore in fase di compilazione. Inoltre, non vi è alcun problema se il metodo sottoposto a override della sottoclasse non genera alcuna eccezione.
Giava
// Java program to demonstrate overriding when> // superclass method does declare an exception> class> Parent {> >void> m1()>throws> RuntimeException> >{> >System.out.println(>'From parent m1()'>);> >}> }> class> Child1>extends> Parent {> >@Override> >// no issue while throwing same exception> >void> m1()>throws> RuntimeException> >{> >System.out.println(>'From child1 m1()'>);> >}> }> class> Child2>extends> Parent {> >@Override> >// no issue while throwing subclass exception> >void> m1()>throws> ArithmeticException> >{> >System.out.println(>'From child2 m1()'>);> >}> }> class> Child3>extends> Parent {> >@Override> >// no issue while not throwing any exception> >void> m1()> >{> >System.out.println(>'From child3 m1()'>);> >}> }> class> Child4>extends> Parent {> >@Override> >// compile-time error> >// issue while throwing parent exception> >void> m1()>throws> Exception> >{> >System.out.println(>'From child4 m1()'>);> >}> }> |
>
>
Produzione
error: m1() in Child4 cannot override m1() in Parent void m1() throws Exception ^ overridden method does not throw Exception>
Metodo prioritario e astratto
I metodi astratti in un'interfaccia o in una classe astratta devono essere sovrascritti nelle classi concrete derivate, altrimenti verrà generato un errore in fase di compilazione.
Metodo di override e sincronizzato/strictfp
La presenza di un modificatore sincronizzato/strictfp con il metodo non ha alcun effetto sulle regole di overriding, ovvero è possibile che un metodo sincronizzato/strictfp possa sovrascrivere uno non sincronizzato/strictfp e viceversa.
Nota:
- In C++, abbiamo bisogno parola chiave virtuale per ottenere l'override o Polimorfismo in fase di esecuzione . In Java, i metodi sono virtuali per impostazione predefinita.
- Possiamo avere l'override del metodo multilivello.
Giava
// A Java program to demonstrate> // multi-level overriding> // Base Class> class> Parent {> >void> show() { System.out.println(>'Parent's show()'>); }> }> // Inherited class> class> Child>extends> Parent {> >// This method overrides show() of Parent> >void> show() { System.out.println(>'Child's show()'>); }> }> // Inherited class> class> GrandChild>extends> Child {> >// This method overrides show() of Parent> >void> show()> >{> >System.out.println(>'GrandChild's show()'>);> >}> }> // Driver class> class> Main {> >public> static> void> main(String[] args)> >{> >Parent obj1 =>new> GrandChild();> >obj1.show();> >}> }> |
>
>Produzione
GrandChild's show()>
Overriding del metodo e sovraccarico del metodo
1. Sovraccarico riguarda lo stesso metodo con firme diverse. L'override riguarda lo stesso metodo e la stessa firma ma classi diverse collegate tramite ereditarietà.
2. L'overloading è un esempio di polimorfismo in fase di compilazione e l'override è un esempio di runtime polimorfismo .
Domande frequenti sull'override del metodo Java
Q1. Che cos'è l'override del metodo?
Come affermato in precedenza, i metodi sovrascritti consentono a Java di supportare polimorfismo in fase di esecuzione . Il polimorfismo è essenziale per la programmazione orientata agli oggetti per una ragione: consente a una classe generale di specificare metodi che saranno comuni a tutti i suoi derivati mentre consente alle sottoclassi di definire l'implementazione specifica di alcuni o tutti questi metodi. I metodi sovrascritti sono un altro modo in cui Java implementa l'aspetto del polimorfismo con un'unica interfaccia e più metodi. Invio del metodo dinamico è uno dei meccanismi più potenti che la progettazione orientata agli oggetti mette a disposizione per il riutilizzo e la robustezza del codice. La capacità di esistere librerie di codice per chiamare metodi su istanze di nuove classi senza ricompilare mantenendo un'interfaccia astratta pulita è uno strumento profondamente potente. I metodi sottoposti a override ci consentono di chiamare metodi di qualsiasi classe derivata senza nemmeno conoscere il tipo di oggetto della classe derivata.
Q2. Quando applicare l'overriding del metodo? (con esempio)
Sovrapposizione e Eredità : Parte della chiave per applicare con successo il polimorfismo è comprendere che le superclassi e le sottoclassi formano una gerarchia che si muove dalla specializzazione minore a quella maggiore. Se utilizzata correttamente, la superclasse fornisce tutti gli elementi che una sottoclasse può utilizzare direttamente. Definisce inoltre i metodi che la classe derivata deve implementare da sola. Ciò consente alla sottoclasse la flessibilità di definire i propri metodi, pur applicando un'interfaccia coerente. Pertanto, combinando l'ereditarietà con i metodi sovrascritti, una superclasse può definire la forma generale dei metodi che verranno utilizzati da tutte le sue sottoclassi. Diamo un'occhiata a un esempio più pratico che utilizza l'override del metodo. Considera un software di gestione dei dipendenti per un'organizzazione, lascia che il codice abbia una semplice classe base Employee e la classe abbia metodi come raiseSalary(), transfer(), promo(), .. ecc. Diversi tipi di dipendenti come Manager, Ingegnere, ..etc possono avere le loro implementazioni dei metodi presenti nella classe base Employee. Nel nostro software completo, dobbiamo solo passare un elenco di dipendenti ovunque e chiamare i metodi appropriati senza nemmeno conoscere il tipo di dipendente. Ad esempio, possiamo facilmente aumentare lo stipendio di tutti i dipendenti scorrendo l'elenco dei dipendenti. Ogni tipo di dipendente può avere la sua logica nella sua classe, non dobbiamo preoccuparci perché se raiseSalary() è presente per un tipo specifico di dipendente, verrebbe chiamato solo quel metodo.
Giava
// Java program to demonstrate application>// of overriding in Java>// Base Class>class>Employee {>>public>static>int>base =>10000>;>>int>salary() {>return>base; }>}>// Inherited class>class>Manager>extends>Employee {>>// This method overrides salary() of Parent>>int>salary() {>return>base +>20000>; }>}>// Inherited class>class>Clerk>extends>Employee {>>// This method overrides salary() of Parent>>int>salary() {>return>base +>10000>; }>}>// Driver class>class>Main {>>// This method can be used to print the salary of>>// any type of employee using base class reference>>static>void>printSalary(Employee e)>>{>>System.out.println(e.salary());>>}>>public>static>void>main(String[] args)>>{>>Employee obj1 =>new>Manager();>>// We could also get type of employee using>>// one more overridden method.loke getType()>>System.out.print(>'Manager's salary : '>);>>printSalary(obj1);>>Employee obj2 =>new>Clerk();>>System.out.print(>'Clerk's salary : '>);>>printSalary(obj2);>>}>}>>ordinamento per inserimento java>ProduzioneManager's salary : 30000 Clerk's salary : 20000>
Articolo correlato
- Dispatch del metodo dinamico o polimorfismo di runtime in Java
- Sostituzione del metodo equals() della classe Object
- Override del metodo toString() della classe Object
- Sovraccarico in Java
- Output del programma Java | Imposta 18 (override)