Tipi di polimorfismo in Java | Spiegato

Il polimorfismo è un'abilità che consente a un oggetto di trasportare molte forme o in parole semplici ci consente di creare di eseguire un'unica attività in vari modi. Ad esempio, il polimorfismo ci consente di creare più metodi con lo stesso nome, ma l'implementazione di ciascun metodo sarà diversa dall'altro metodo. In Java, il concetto di polimorfismo può essere implementato in fase di esecuzione o in tempo di compilazione.

Questo articolo presenta una panoramica approfondita dei tipi di polimorfismo come elencato di seguito:

• Cos'è il polimorfismo in Java
• Polimorfismo statico/di compilazione in Java
• Polimorfismo dinamico/di runtime in Java

Quindi iniziamo!

Cos'è il polimorfismo in Java

La parola polimorfismo è una combinazione di due parole greche poli significa molti e Morphs significa forme quindi combinatamente la parola polimorfismo significa molte/più forme. Il polimorfismo ci consente di svolgere un compito specifico in vari modi

Esempio

Consideriamo gli esempi del mondo reale elencati di seguito per comprendere il concetto di polimorfismo:

Gli animali suona: Leone ruggisce, abbaiate di cani, vicini di cavallo e così via.

Ora comprendiamo il concetto di cui sopra in termini di programmazione Java, in questo esempio, il Animali è una classe e "Sounds ()" è il suo metodo:

Qui Animali è una classe generale che non può essere limitata con un solo suono come un ruggito, o corteccia, ecc. Quindi, una classe avrà un'implementazione generica che può essere estesa dalle altre classi.

Inoltre, Leone, Cane, E Cavallo (sottoclassi) possono estendere le proprietà della classe genitore Animale. Le classi di figli erediteranno la funzione della loro classe genitore e potranno sovrascrivere l'implementazione di quella funzione.

Quindi il polimorfismo in Java consente di utilizzare lo stesso metodo per eseguire varie funzionalità. In Java, il polimorfismo può essere ottenuto mediante il tempo di compilazione o il runtime.

Polimorfismo statico/di compilazione in Java

Nel polimorfismo a tempo di compilazione, gli oggetti dei CALS sono delimitati con i metodi al tempo di compilazione. Il polimorfismo a tempo di compilazione è gestito dal compilatore e supporta il concetto di sovraccarico di metodi.

Il sovraccarico del metodo nel polimorfismo a tempo di compilazione consente a una classe di creare più metodi con lo stesso nome ma implementazioni diverse in termini di parametri. E esistono alcune regole per questi parametri come elencato di seguito:

Possiamo creare più metodi con lo stesso nome ma con una sequenza/ordine di parametri diverso.

Possiamo creare più di un metodo con lo stesso nome ma con diversi tipi di dati di parametri:

Possiamo creare più metodi con lo stesso nome ma con un numero diverso di parametri.

Consideriamo un esempio per la profonda comprensione del polimorfismo a tempo di compilazione:

Esempio

In questo esempio abbiamo creato due classi:

Moltiplicazione.Giava

IL Moltiplicazione La classe crea tre metodi con lo stesso nome "Prodotto()", Il primo metodo prende due valori interi, il secondo prende due doppi valori e il terzo prende tre valori interi:

pacchetto principale;
moltiplicazione della classe pubblica
int prodotto (int num1, int num2)
restituire num1 * num2;

Double Product (Double Num1, Double Num2)
restituire num1 * num2;

int prodotto (int num1, int num2, int num3)
restituire num1 * num2 * num3;

Lo screenshot del codice sopra dato sarà così:

Principale.Giava

All'interno del Principale Classe, abbiamo creato l'oggetto di moltiplicazione classe e chiamato tutti e tre i metodi del Moltiplicazione classe:

pacchetto principale;
Classe pubblica Main
public static void main (string [] args)
Moltiplicazione obj = new Moltiplication ();
Sistema.fuori.println ("Risultato di due valori int:" + obj.prodotto (5, 12));
Sistema.fuori.println ("Risultato di tre valori int:" + obj.prodotto (4, 15, 2));
Sistema.fuori.println ("Risultato di doppi valori:" + obj.Prodotto (5.5, 2.67));

Il codice completo del Principale La classe è mostrata nella figura seguente:

L'output andrà così:

Dall'output di cui sopra lo osserviamo:

Quando abbiamo superato i due int Valori quindi il Prodotto metodo che ne ha due int I parametri vengono eseguiti.

Quando abbiamo superato i tre int Valori quindi il Prodotto metodo che ha tre int I parametri vengono eseguiti.

Allo stesso modo, quando abbiamo superato i due Doppio Valori quindi il Prodotto metodo che ne ha due Doppio I parametri vengono eseguiti.

Polimorfismo dinamico/di runtime in Java

In Runtime Polimorfismo, gli oggetti sono delimitati con i metodi in fase di esecuzione (legame dinamico). Il polimorfismo dinamico o di runtime supporta il concetto di Metodo prevalente.

• In OOP, il termine prevalente si riferisce che sovrascrive le funzionalità dei metodi esistenti.
• Nel polimorfismo di runtime, il tipo e l'elenco del parametro devono essere gli stessi nel metodo sovrascritto.
• Il tipo di restituzione del metodo deve essere lo stesso sia nella superclasse che nella sottoclasse.
• Una classe genitore che ha un metodo dichiarato con finale, privato o statico non può essere annullata nella sottoclasse, tuttavia un metodo statico può essere rideclarato nella classe figlio.

Diamo un'occhiata all'esempio di seguito per la profonda comprensione del polimorfismo di runtime.

Esempio

Il frammento di codice seguente crea tre classi: Persona, dipendente, E Dipartimento, IL Persona la classe è una classe genitore, il Dipendente La classe si estende Persona classe e Dipartimento la classe si autode Dipendente classe.

persona di classe
public void print ()
Sistema.fuori.println ("Questa è una classe di persona");


Il dipendente di classe estende la persona
public void print ()
Sistema.fuori.println ("Questa è una classe di dipendenti");


Il dipartimento di classe estende i dipendenti
public void print ()
Sistema.fuori.println ("questa è la classe di dipartimento");


classe pubblica runtimexample
public static void main (string [] args)
Persona per = nuova persona ();
Persona emp = new Employee ();
Person Dept = new Dipartimento ();
per.stampa();
Emp.stampa();
Dipartimento.stampa();

Le classi di bambini estendono il stampa() Metodo delle loro classi genitori e hanno anche la propria implementazione di quel metodo Print (). E all'interno del metodo principale, creiamo l'oggetto di ogni classe e chiamiamo il stampa() Metodo con il rispettivo oggetto di classe. Il codice e l'output completo sono forniti nella seguente schermata:

L'output di cui sopra verifica che quando chiamiamo le funzioni di stampa con ciascun oggetto Classe figlio, sovrascrive l'implementazione della funzione di stampa di classe genitore ().

Conclusione

Il polimorfismo ci consente di creare più metodi con lo stesso nome ma con diverse implementazioni nelle classi genitore e figlio. Può essere ottenuto al tempo di compilazione che supporta il concetto di sovraccarico di metodi o in fase di esecuzione che supporta il concetto di prevalenza. Questo articolo presenta una panoramica dettagliata del runtime e del polimorfismo a tempo di compilazione e spiega cosa è il polimorfismo, i suoi tipi e le regole per implementare ogni tipo.