Menu

Java @override: override del metodo e polimorfismo di runtime

  • Principale
  • Altro
  • Java @override: override del metodo e polimorfismo di runtime

java override method overriding

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega come ottenere il polimorfismo di runtime in Java utilizzando l'override del metodo e l'annotazione @override con semplici esempi:

Abbiamo già discusso in dettaglio il concetto di polimorfismo e il polimorfismo in fase di compilazione. In questo tutorial, andremo avanti con il polimorfismo di Runtime in Java.

A differenza del polimorfismo in fase di compilazione in cui la chiamata al metodo viene risolta in fase di compilazione, nel polimorfismo a runtime, la chiamata al metodo viene risolta in fase di esecuzione.

=> Controlla TUTTI i tutorial Java qui.

@override_ Sostituzione del metodo in Java

Cosa imparerai:

Polimorfismo di runtime in Java

Un polimorfismo a runtime noto anche come polimorfismo dinamico o Spedizione metodo dinamico è un tecnica in cui una chiamata al metodo sovrascritta viene risolta dinamicamente in fase di esecuzione.

Il polimorfismo di runtime in Java si ottiene utilizzando ' sovrascrittura del metodo '. L'override del metodo è una tecnica con cui un metodo nella classe genitore viene ridefinito o sovrascritto nella classe figlia.

Quando il metodo viene sovrascritto in una classe, la tecnica di invio del metodo dinamico risolve la chiamata al metodo sottoposto a override in fase di esecuzione e non in fase di compilazione.

Ottieni il polimorfismo di runtime in Java - Sostituzione del metodo

L'override del metodo è l'approccio che utilizziamo per ottenere il polimorfismo di runtime in Java. Come già accennato, l'override del metodo è una tecnica in cui la sottoclasse aggiunge un metodo che è già presente nella sua classe genitore e aggiunge nuove funzionalità a questo metodo. Quindi diciamo che il metodo della classe base è sovrascritto.

Il nuovo metodo che abbiamo definito nella sottoclasse con lo stesso prototipo del metodo della classe genitore ma con un'implementazione diversa è chiamato ' metodo di sostituzione ' . Il metodo nella classe genitore è noto come ' Metodo ignorato '.

come scrivere casi di test in Excel

Una volta che il metodo è stato sovrascritto, resta la domanda su come viene risolta la chiamata a questo metodo sottoposto a override?

Di solito chiamiamo il metodo sovrascritto tramite il riferimento della classe base. Creeremo un riferimento di tipo base e quindi assegneremo un oggetto di classe figlio utilizzando la nuova parola chiave.

Quindi dipende dal contenuto della variabile di riferimento o dall'oggetto a cui fa riferimento il riferimento alla classe di base che determina quale metodo deve essere chiamato. Quindi, se gli oggetti di riferimento puntano all'oggetto della classe figlia, viene chiamato il metodo di sovrascrittura.

Altrimenti, se l'oggetto di riferimento contiene un oggetto di classe base, viene chiamato il metodo sostituito. Un argomento che dobbiamo essere chiari nel polimorfismo a runtime, in particolare per l'invio di metodi dinamici, è 'Upcasting', che viene spiegato di seguito.

Upcasting

Quando un oggetto di riferimento della classe genitore di cui abbiamo discusso in precedenza punta o fa riferimento all'oggetto della sottoclasse, lo chiamiamo Upcasting.

Upcasting

Comprendiamo l'upcasting utilizzando un semplice esempio.

Considera che abbiamo una classe 'BaseClass' ed estendiamo questa BaseClass per creare una nuova classe DerivedClass. Questa struttura appare come mostrato di seguito.

class BaseClass { ….//BaseClass code here } class DerivedClass extends BaseClass{ ….//DerivedClass code here }

Ora per implementare l'upcasting dichiareremo una variabile di riferimento di tipo BaseClass. Successivamente, assegniamo un oggetto di DerivedClass al riferimento della classe BaseClass come fatto nell'istruzione di codice seguente.

BaseClass base = new DerivedClass (); //Upcasting

Quindi qui possiamo dire che abbiamo eseguito l'upcast dell'oggetto DerivedClass a BaseClass. Per quanto riguarda il polimorfismo di runtime il concetto di upcasting è molto importante.

Quindi, in generale, l'upcasting è il processo di assegnazione di oggetti figlio o sottoclasse al riferimento di un genitore o di una superclasse.

SuperClass reference = new Subclass Object;

Il programma Java di seguito mostra l'override del metodo e mostra anche come viene eseguito l'upcasting per risolvere le chiamate al metodo sovrascritte in fase di esecuzione.

//base/parent class class Parent { void Print() //print method { System.out.println('Parent::Print() method'); } } //child class 1 inheriting from Parent class child1 extends Parent { void Print() //overridden print method { System.out.println('child1::Print() method'); } } //child class 2 inheriting from Parent class child2 extends Parent { void Print() //overridden print method { System.out.println('child2::Print() method'); } } class Main { public static void main(String() args) { Parent parent = new Parent(); parent.Print(); //executes parent Print () method parent = new child1(); //upcasting parent.Print(); //executes child1 Print () method parent = new child2(); //upcasting parent.Print(); //executes child2 Print () method

Produzione:

Upcasting - output

Nel programma precedente, abbiamo due classi, ovvero child1 e child2, entrambe derivate da una classe 'Parent'. La classe padre ha un metodo 'Print' che viene sovrascritto in entrambe le classi child1 e child2. Quindi, nel metodo main, creiamo un oggetto di riferimento della classe Parent denominato 'parent'.

Per prima cosa, gli assegniamo un oggetto della classe Parent e poi chiamiamo il metodo 'Print ()'. Quindi lo ripetiamo assegnando prima l'oggetto child1 e poi l'oggetto child2 al riferimento Parent.

aggiunta di un elemento a un array java

L'output viene visualizzato, a seconda del contenuto del riferimento padre, e viene chiamato il metodo Print appropriato.

Vantaggi del polimorfismo dinamico / runtime

  • Con il polimorfismo dinamico, il programmatore è autorizzato a sovrascrivere i metodi.
  • Consente alle classi di definire un metodo con un'implementazione generale che i suoi derivati ​​possono quindi sovrascrivere e fornire l'implementazione specifica.
  • Con l'invio dinamico del metodo, la chiamata al metodo viene risolta in fase di esecuzione, a differenza del sovraccarico che viene deciso in fase di compilazione. Ciò consente una maggiore flessibilità per i programmatori.

Poiché il polimorfismo di runtime lega il metodo appropriato alla chiamata in fase di esecuzione e lo chiamiamo anche associazione dinamica o associazione tardiva . Il polimorfismo in fase di compilazione invece supporta associazione statica o associazione anticipata .

Legame statico e dinamico

Legame staticoAssociazione dinamica
La chiamata al metodo risolta in fase di compilazione è un'associazione statica.La chiamata al metodo risolta in fase di esecuzione è un binding dinamico.
Il sovraccarico del metodo è un esempio di associazione statica.L'override del metodo è un esempio di associazione dinamica.
I tipi di classe e di campo vengono utilizzati per l'associazione statica.Gli oggetti vengono utilizzati per l'associazione dinamica.
Le entità private, finali e statiche utilizzano l'associazione statica.I metodi virtuali utilizzano l'associazione dinamica.

Funzione / metodo virtuale in Java

La funzione o il metodo virtuale in Java è una funzionalità utilizzata con il polimorfismo di runtime. A differenza di C ++, Java non ha una parola chiave 'virtuale' speciale per denotare che un metodo è virtuale. Un metodo definito nella classe base e sottoposto a override nella classe derivata è virtuale.

In Java, per impostazione predefinita, ogni metodo non statico ad eccezione di private e final è una funzione virtuale. Quindi si noti che i metodi che abbiamo discusso in precedenza che sovrascrivono per implementare il polimorfismo di runtime sono anche metodi virtuali.

Poiché il metodo statico è associato a Class e non può essere chiamato utilizzando un oggetto, non può essere utilizzato con il polimorfismo di runtime e non è nemmeno una funzione virtuale.

Le interfacce in Java sono virtuali per impostazione predefinita. Le classi che implementano interfacce forniscono implementazioni per i metodi di interfaccia. Come nel polimorfismo di runtime, anche la chiamata ai metodi di interfaccia viene risolta in fase di runtime.

Ricorda che poiché i metodi in un'interfaccia sono progettati per essere sovrascritti, tutti i metodi dell'interfaccia sono funzioni virtuali.

Si consideri ad esempio il codice seguente:

interface car{ void accelerate(); } class Maruti implements car{ void accelerate () { System.out.println(“Maruti car accelerated!!”); } }

Nel codice sopra, il metodo accelerate () è una funzione virtuale in quanto fa parte dell'interfaccia auto ed è progettato per essere sovrascritto.

@override Annotation In Java

L'annotazione @override è l'annotazione predefinita in Java. Questa annotazione è stata introdotta in Java 1.5. L'annotazione @override viene utilizzata quando il metodo della sottoclasse sovrascrive il metodo della superclasse.

Utilizzando l'annotazione Java @override per indicare che il metodo sta sovrascrivendo il metodo della sua classe genitore, un compilatore emette un avviso se il metodo annotato non viene sovrascritto. Quindi rende obbligatorio l'override del metodo quando viene utilizzata l'annotazione @override.

In secondo luogo, utilizzando l'annotazione @override rendiamo il codice più leggibile. Possiamo subito renderci conto che il metodo dichiarato deve essere sovrascritto.

La sintassi generale dell'annotazione Java @override è

public @interface override

Il seguente programma Java mostra l'utilizzo dell'annotazione @override.

//base class definition class BaseClass { public void display() { System.out.println('BaseClass::display () method'); } } //derived class inheriting base class class DerivedClass extends BaseClass { @Override //indicates the display method being overridden public void display() { System.out.println('DerivedClass::display () method'); } } // main class public class Main { public static void main(String args()) { System.out.println('@Override Example'); //BaseClass type object;contain child object BaseClass testObj = new DerivedClass(); //call display method based on contents of object i.e. derived class display () testObj.display(); } }

Produzione:

@Override Esempio

Nel programma sopra, abbiamo una BaseClass che definisce un metodo di visualizzazione. Quindi deriviamo una classe DerivedClass da questa BaseClass e contrassegniamo il metodo di visualizzazione con l'annotazione @override. Questo metodo viene sottoposto a override in DerivedClass.

Nel metodo main, creiamo un riferimento all'oggetto BaseClass e lo puntiamo all'oggetto DerivedClass che fa sì che il riferimento chiami il metodo di visualizzazione DerivedClass.

Se non avessimo implementato il metodo display () nella classe Derived, il compilatore avrebbe dato un avvertimento al compilatore poiché è contrassegnato con l'annotazione @override.

Sovraccarico e sovrascrittura in Java

Ora che abbiamo discusso sia del sovraccarico che dell'override in Java, riassumiamo questi due concetti.

Il sovraccarico è correlato al polimorfismo in fase di compilazione, ovvero implementiamo il polimorfismo in fase di compilazione utilizzando il sovraccarico. Il sovraccarico viene eseguito in due modi, ovvero il sovraccarico del metodo e il sovraccarico dell'operatore.

Il sovraccarico dei metodi è la tecnica in cui abbiamo più di un metodo con lo stesso nome ma elenchi di parametri diversi. L'elenco dei parametri è differenziato in base al numero di parametri, ai tipi di parametri o alla sequenza di parametri.

Il sovraccarico degli operatori in Java è limitato e ci consente di sovraccaricare solo l'operatore '+' che viene utilizzato per aggiungere due numeri e concatenare due oggetti String.

Il sovraccarico viene risolto in fase di compilazione ed è statico. È anche chiamato 'Associazione anticipata' .

come istanziare un elenco in java

Il metodo Overriding è una funzionalità che utilizza il polimorfismo di runtime. Nella sostituzione del metodo, un metodo della classe genitore viene sovrascritto nella classe figlia. Ciò significa che il prototipo del metodo sia nella super che nella sottoclasse rimane lo stesso ma le implementazioni sono diverse.

L'override del metodo utilizza la tecnica di invio del metodo dinamico per risolvere la chiamata al metodo e decidere se chiamare un metodo di superclasse o sottoclasse e questo viene fatto in fase di esecuzione.

Quindi il polimorfismo di runtime è anche chiamato polimorfismo dinamico o associazione tardiva.

Successivamente, tabularizziamo le differenze tra il sovraccarico e l'override in Java.

Sovraccarico rispetto all'override in Java

SovraccaricoOverriding
Il sovraccarico viene utilizzato nel polimorfismo in fase di compilazione.L'override è implementato nel polimorfismo di runtime.
Può essere fatto nella stessa classe. Può o non può richiedere l'eredità.L'override richiede sempre l'ereditarietà.
I metodi vengono sovraccaricati con lo stesso nome di metodo e un elenco di parametri diverso.I metodi sostituiti hanno gli stessi prototipi.
Il tipo restituito non viene considerato nell'overload del metodo.Il tipo restituito dovrebbe essere lo stesso nei metodi sostituiti e sostituiti.
Migliora la leggibilità del programma.L'override consente di avere una classe di implementazione specifica.

Domande frequenti

D # 1) Possiamo sovrascrivere il metodo statico?

Risposta: No. I metodi statici non possono essere sovrascritti in Java. Questo perché i metodi statici sono basati sulla classe e vengono chiamati direttamente dalla classe. Non hanno bisogno di oggetti da richiamare in fase di esecuzione. Quindi l'invio del metodo statico è determinato dal compilatore.

D # 2) Possiamo sovrascrivere il costruttore?

Risposta: No, non possiamo sovrascrivere un costruttore. Quando viene creato l'oggetto, viene chiamato un costruttore. Non è chiamato oggetto. Inoltre, uno dei requisiti per l'override è il metodo sovrascritto e il metodo override dovrebbe avere la stessa firma del metodo che non è possibile nel caso dei costruttori.

D # 3) Perché l'override del metodo viene chiamato polimorfismo dinamico?

Risposta: In caso di override del metodo, la chiamata al metodo viene risolta dinamicamente in fase di esecuzione. Quindi si chiama polimorfismo dinamico.

D # 4) Qual è l'uso del polimorfismo dinamico in Java?

Risposta: Il polimorfismo dinamico utilizza una tecnica di invio del metodo dinamico che supporta l'override del metodo in modo che la sottoclasse possa fornire un'implementazione specifica al metodo sovrascritto. In questo modo possiamo implementare le funzionalità specifiche che ci consentono di scrivere programmi efficienti.

In secondo luogo, non dobbiamo nemmeno preoccuparci di risolvere le chiamate al metodo poiché l'invio dinamico del metodo decide quale metodo chiamare.

D # 5) Qual è la differenza tra binding statico e dinamico?

Risposta: Il collegamento tra una chiamata al metodo e la sua implementazione è chiamato binding. Quando questo collegamento viene risolto in fase di compilazione, lo chiamiamo binding statico. Quando l'associazione viene eseguita dinamicamente in fase di esecuzione, viene chiamata associazione dinamica.

L'associazione statica utilizza il tipo di dati della classe e dei campi per risolvere le chiamate al metodo. L'associazione dinamica utilizza oggetti per risolvere le chiamate ai metodi. L'associazione statica è anche chiamata polimorfismo in fase di compilazione e l'associazione dinamica è anche chiamata polimorfismo di runtime.

Conclusione

In questo tutorial, abbiamo discusso in dettaglio il polimorfismo di runtime in Java.

Il polimorfismo di runtime viene implementato utilizzando l'override del metodo. La sostituzione del metodo viene eseguita nella sottoclasse in cui un metodo definito nella superclasse viene ridefinito o sovrascritto nella sua sottoclasse. La firma del metodo rimane la stessa nella super e nella sottoclasse.

Utilizzando l'override del metodo possiamo fornire un'implementazione specifica per lo stesso metodo nella sottoclasse. In questo modo, possiamo scrivere programmi più efficienti che coinvolgono l'ereditarietà. Java fornisce l'annotazione @override per indicare che il metodo deve essere sovrascritto.

Per impostazione predefinita, tutti i metodi non statici che non sono finali sono virtuali in Java. Tutti i metodi virtuali possono essere sovrascritti.

=> Guarda qui la serie di formazione su Java semplice.

Lettura consigliata

^