Menu

Cos'è il polimorfismo in Java - Tutorial con esempi

what is polymorphism java tutorial with examples

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega cos'è il polimorfismo in Java, i tipi di polimorfismo e come implementare il polimorfismo in fase di compilazione con esempi:

La parola 'polimorfismo' deriva da due parole, ad es. 'Poli' che significa molti e ' morph 'Che significa forme. Quindi polimorfismo significa molte forme. In un linguaggio di programmazione, possiamo dire che un oggetto può assumere molte forme, e quindi l'oggetto è polimorfico.

Il polimorfismo è una delle caratteristiche più importanti dell'OOP e ci consente di esprimere una caratteristica (un oggetto o un messaggio o un metodo o un operatore) in varie forme.

=> Dai un'occhiata alla guida per principianti di Java qui.

Cos

Cosa imparerai:

Introduzione al polimorfismo in Java

L'entità polimorfica si comporta in modo diverso in diversi scenari.

Per esempio, considera un operatore '+' (addizione) in Java. Questo è un operatore binario e accetta due operandi. Quando gli operandi passati all'operatore '+' sono numeri, viene eseguita un'operazione di addizione che restituisce la somma di due numeri.

Quando gli operandi cambiano in tipo String, l'operatore '+' non aggiunge gli oggetti String, ma concatena o unisce il contenuto della stringa per formare una terza stringa risultante.

Per esempio, Se ' uno ' e ' Due 'Sono quindi il contenuto di due oggetti String 'Uno' + 'due' risulterà in ' uno due '. Questa è la concatenazione.

In Java, tutti gli oggetti sono polimorfici poiché derivano tutti dalla classe 'Object' e quindi soddisfano la relazione 'IS-A' con la classe Object.

Si accede sempre a un oggetto tramite una variabile di riferimento di quel particolare tipo di classe. Una volta dichiarata una variabile di riferimento di un tipo particolare, non può essere modificata. Tuttavia, se la variabile di riferimento non è dichiarata come 'Finale', possiamo riassegnarla in modo che punti ad altri oggetti.

Il tipo di questo riferimento all'oggetto deciderà i metodi o le funzioni della classe che dovrebbero essere chiamati.

Per esempio,se esiste una classe ABC e una classe XYZ derivata da ABC, entrambe le classi hanno un metodo polimorfico func ().

class ABC{ void func(){} } class XYZ extends ABC{ void func() {} }

Creiamo un riferimento di tipo ABC.

obj = new XYZ ();

Ora, quando chiamiamo il metodo func (), poiché l'oggetto puntato da obj è di classe XYZ, verrà invocato il metodo func () della classe XYZ.

Come abbiamo visto nell'esempio precedente, il metodo func () ha implementazioni diverse ma lo stesso prototipo. A seconda dell'oggetto puntato dall'oggetto di riferimento, abbiamo l'implementazione appropriata in quello scenario invocato. Questo è polimorfismo.

Parliamo in dettaglio del polimorfismo in Java.

Esempio di polimorfismo Java

Vediamo un semplice esempio di polimorfismo in Java con l'operazione di addizione come discusso in precedenza.

Qui usiamo due metodi con lo stesso nome ma parametri differenti. La prima funzione accetta due parametri interi e il secondo metodo accetta due parametri stringa.

A seconda del tipo di parametri passati, viene chiamato il metodo appropriato e aggiunge due numeri interi e stampa il risultato oppure concatena le due stringhe e stampa la stringa risultante.

Di seguito viene fornito il programma Java:

class Addition_operation{ //method to add two integers void addition_func(int num1,int num2){ System.out.println('ABC::addition_func:' + (num1+num2)); } //overloaded method to add two strings void addition_func(String str1, String str2){ String result = str1 + ' ' + str2; System.out.println('XYZ::addition_func:' + result); } } public class Main { public static void main(String() args) { Addition_operation abc = new Addition_operation(); //create a class object abc.addition_func (3,4); //calls 1st method abc.addition_func ('Hello' , 'World!'); //calls 2nd method } }

Produzione:

Output - Esempio di polimorfismo

Qui abbiamo visto che la prima volta che passiamo due parametri interi a addition_func, viene chiamato il primo metodo. Nella seconda chiamata di funzione, passiamo due parametri di tipo String e quindi viene chiamato il secondo metodo sovraccaricato.

Tipi di polimorfismo

Java supporta due tipi di polimorfismo:

  • Polimorfismo in fase di compilazione
  • Polimorfismo run-time

Tipi di polimorfismo in Java

Come suggerisce il nome, il polimorfismo in fase di compilazione viene eseguito in fase di compilazione e il polimorfismo in fase di esecuzione viene eseguito in fase di esecuzione.

Come mostrato nella figura sopra, il polimorfismo in fase di compilazione viene implementato tramite Overloading. Possiamo sovraccaricare il metodo o l'operatore. Il polimorfismo di runtime si ottiene tramite Override.

In questo tutorial, discuteremo in dettaglio il polimorfismo in fase di compilazione. Affronteremo il polimorfismo a runtime nel prossimo tutorial.

Polimorfismo in fase di compilazione in Java

Il polimorfismo in fase di compilazione è anche noto come 'polimorfismo statico'. Come parte del polimorfismo in fase di compilazione, qualunque polimorfismo deve essere eseguito, viene eseguito in fase di compilazione.

In Java, il polimorfismo in fase di compilazione viene eseguito utilizzando ' Metodo di sovraccarico '. Utilizzando il sovraccarico dei metodi, possiamo avere uno o più metodi con lo stesso nome e differenziati solo per numeri o tipo o ordine dei parametri.

Il sovraccarico dei metodi è l'implementazione più comune del polimorfismo in fase di compilazione in Java. Java supporta anche il sovraccarico dell'operatore.

Che cos'è l'overload in Java in generale?

Il sovraccarico in Java è un processo che consiste nell'avere più di un metodo con lo stesso nome e tipo restituito ma diversi per sequenza, numero e tipo di argomenti. Viene anche chiamato sovraccarico del metodo in generale.

Overload del metodo in Java

Il sovraccarico del metodo è un'implementazione del polimorfismo in fase di compilazione in Java. Quando abbiamo uno o più metodi con lo stesso nome e / o tipi restituiti ma elenchi di parametri diversi, allora diciamo che abbiamo 'sovraccaricato' i metodi.

Quindi, in una data classe, possiamo avere vari metodi con lo stesso nome ma elenchi di argomenti diversi.

Come si invocano metodi sovraccaricati? O come fa il compilatore a sapere quale metodo deve essere chiamato?

Il richiamo del metodo esatto che corrisponde alla chiamata viene eseguito a seconda dell'elenco dei parametri.

Abbiamo già visto che una classe in Java può avere più di un costruttore. Nel caso dei costruttori, l'elenco degli argomenti o gli argomenti che il costruttore accetta è diverso in tutti i costruttori. Questo è un esempio di sovraccarico. Quindi il sovraccarico del costruttore è una forma base di sovraccarico del metodo in Java.

Ora vediamo come caricare un metodo in Java?

Java fornisce tre modi per il sovraccarico del metodo a seconda delle variazioni nell'elenco di parametri / argomenti.

# 1) Tipo di parametri

Possiamo sovraccaricare i metodi in Java a seconda del tipo di dati dei parametri.

Considera il seguente esempio in cui abbiamo fornito prototipi di tre metodi.

addizione (int, int);
addizione (int, float);
addizione (String, String);

Come visto dall'alto, abbiamo lo stesso nome di metodo in tutti e tre i casi e lo stesso numero di parametri ma ogni chiamata di metodo ha diversi tipi di parametri.

Quindi, finché i metodi hanno diversi tipi di parametri, possiamo dire che i metodi sono sovraccaricati. Quando invochiamo il metodo, il compilatore decide il tipo di dati del parametro e, a seconda del tipo di dati dell'elenco di parametri fornito con la chiamata al metodo, viene chiamato il metodo appropriato.

Per esempio,se abbiamo una chiamata al metodo come di seguito:

aggiunta (3, 3.5);

Nella chiamata al metodo sopra, possiamo vedere che il primo parametro è di tipo int mentre il secondo parametro è di tipo float. Quando viene rilevata la chiamata precedente, il compilatore risolve l'elenco dei parametri e quindi richiama il metodo appropriato che è il secondo metodo sopra.

Ora implementiamo un programma Java completo per dimostrare il sovraccarico del metodo in base ai tipi di dati dei parametri.

class MethodOverload { //overloaded method - char parameter public void printParam(char ch) { System.out.println('Input character:' + ch); } //overloaded method - int parameter public void printParam(int num) { System.out.println('Input Number:' + num); } } class Main { public static void main(String args()) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (char ) obj.printParam(10); //call overloaded method (int ) } }

Produzione:

Tipo di parametri - output

# 2) Numero di parametri

Un'altra implementazione dell'overload dei metodi è l'overload dei metodi con un numero diverso di parametri nella chiamata di funzione.

Per esempio,consideriamo le seguenti dichiarazioni di metodo:

addnum (int, int);

addnum (int, int, int);

Nelle dichiarazioni di metodo precedenti, la prima dichiarazione di metodo ha due parametri e la seconda dichiarazione ha tre parametri. Quando viene richiamata una funzione, il compilatore controlla il numero di parametri e quindi risolve la chiamata al metodo in modo appropriato.

L'esempio seguente mostra il programma che utilizza il sovraccarico del metodo in base al numero di parametri.

class MethodOverload { //overloaded method - 1 parameter public void printParam(char ch) { System.out.println(ch); } //overloaded method - 2 parameters public void printParam(char ch, int num) { System.out.println('Character: ' + ch + ' ; '+ 'Number:' +num); } } class Main { public static void main(String args()) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (1 ) obj.printParam('A',10); //call overloaded method (2 ) } }

Produzione:

numero di parametri - output

In questo esempio, abbiamo due metodi sovraccaricati in base al numero di parametri. Il primo metodo accetta un parametro e il secondo metodo accetta due parametri. Nel metodo principale, chiamiamo entrambi i metodi uno dopo l'altro e il compilatore risolve la chiamata alla funzione in base al numero di parametri specificati.

# 3) Sequenza di parametri

Il terzo approccio di implementazione del sovraccarico del metodo si basa sulla sequenza di parametri nei metodi sovraccaricati.

Considera il seguente esempio della dichiarazione del metodo,

sum (int, float);
sum (float, int);

Qui abbiamo una somma del metodo sovraccaricata. Nella prima dichiarazione, i parametri sono int e float. Anche nella seconda dichiarazione, i parametri sono int e float ma il loro ordine nell'elenco dei parametri viene modificato.

Ora il parametro float appare per primo mentre il parametro int è il secondo. Possiamo ottenere il sovraccarico del metodo, modificando l'ordine dei parametri.

Il sotto il programma Java lo dimostra.

class MethodOverload { //overloaded method - char,int parameter public void printParam(char ch, int num) { System.out.println('Input character:' + ch + ' ; ' + 'Input Number:' + num); } //overloaded method - int,char parameter public void printParam(int num, char ch) { System.out.println('Input Number:' + num + ' ; ' + 'Input Character:' + ch); } } class Main { public static void main(String args()) { MethodOverload obj = new MethodOverload(); obj.printParam('A', 100); //call overloaded method (char,int) obj.printParam(100, 'A'); //call overloaded method (int,char) } }

Produzione:

Sequenza dei parametri - output

Nel programma sopra, abbiamo un metodo sovraccarico printParam che ha parametri int e char il cui ordine viene modificato in due dichiarazioni di metodo.

Casi non validi di sovraccarico del metodo

Finora abbiamo discusso il sovraccarico del metodo utilizzando l'elenco dei parametri. Non abbiamo ancora considerato il tipo di metodo restituito. Si noti che non sovraccarichiamo i metodi in base ai tipi restituiti.

Ad esempio, se due metodi hanno lo stesso nome e gli stessi elenchi di parametri ma tipi restituiti diversi, non diciamo che questi due metodi sono sovraccarichi. Questo caso diventa non valido per il sovraccarico.

Quindi, se abbiamo le seguenti dichiarazioni:

I int (int, int);
String sum (int, int);

In questo caso, il compilatore emetterà un errore poiché due metodi non sono sovraccaricati. Pertanto, in base esclusivamente ai tipi di restituzione, i metodi non sono differenziati.

Dimostriamo questo caso non valido utilizzando un programma Java.

class OverloadDemo { public double myMethod(int num1, int num2) { System.out.println('OverloadDemo::myMethod returns double'); return num1+num2; } public int myMethod(int var1, int var2) { System.out.println('OverloadDemo::myMethod returns int'); return var1-var2; } } class Main { public static void main(String args()) { OverloadDemo obj2= new OverloadDemo(); obj2.myMethod(10,10); obj2.myMethod(20,12); } }

Nel programma sopra, il metodo myMethod ha due prototipi. Un prototipo accetta due parametri int e restituisce double. Il secondo prototipo di metodo accetta due parametri int e restituisce un int.

Quindi, quando compiliamo questo programma, otteniamo l'output seguente.

Produzione:

Caso non valido di sovraccarico del metodo

L'errore di compilazione precedente indica che il metodo è stato dichiarato due volte. Ciò significa che il compilatore non considera questi metodi sovraccaricati semplicemente in base al tipo restituito.

qual è la fase di implementazione nel sdlc

Sovraccarico dell'operatore

Il sovraccarico degli operatori è un meccanismo di sovraccarico in cui viene dato un significato diverso a un operatore esistente.

Come abbiamo discusso nella sezione introduttiva di questo tutorial, un operatore di addizione '+' è un classico esempio di sovraccarico di operatori.

Quando gli operandi di questo operatore sono numerici, l'operatore + restituisce il totale di due valori. Ma quando gli operandi sono di tipo String, il risultato dell'operazione di addizione è la stringa concatenata. Nota che in Java possiamo solo sovraccaricare l'operatore + (addizione).

Questo operatore svolge due funzioni:

  • Aggiunta di numeri interi o valori numerici.
  • Concatenazione di stringhe

Quindi il supporto per l'overloading degli operatori è limitato in Java a differenza di C ++ in cui possiamo sovraccaricare quasi tutti gli operatori tranne alcuni come sizeof, operatore punto, ecc.

Il programma seguente mostra l'overload dell'operatore in Java.

class OperatorOverload { //overloaded method for concatenating two strings void operator(String str1, String str2) { String resultStr = str1 + str2; System.out.println('Concatenated String: ' + resultStr); } //overloaded method for adding two numbers void operator(int num1, int num2) { int result = num1 + num2; System.out.println('Sum of two numbers : ' + result); } } class Main { public static void main(String() args) { OperatorOverload obj = new OperatorOverload(); obj.operator(10, 15); //add two numbers obj.operator('Hello ', 'World!!'); //concatenate two strings } }

Produzione:

Sovraccarico dell

Nel programma precedente, abbiamo sovraccaricato l'operatore '+'. Quando passiamo due valori interi al metodo sovraccarico, viene restituita una somma di due interi e quando vengono passate due stringhe il risultato è la stringa concatenata.

Alcuni punti da notare per quanto riguarda il sovraccarico e il polimorfismo in fase di compilazione.

  1. Il sovraccarico dei metodi è il modo per implementare il polimorfismo in fase di compilazione noto anche come polimorfismo statico.
  2. Il polimorfismo statico è anche noto come associazione anticipata o associazione in fase di compilazione.
  3. Poiché l'associazione di parametri e la chiamata di funzione avviene in fase di compilazione, il sovraccarico viene chiamato associazione in fase di compilazione.
  4. Possiamo solo sovraccaricare l'operatore '+' in Java ed esegue l'aggiunta di due numeri interi o la concatenazione di due stringhe.

Domande frequenti

D # 1) Perché abbiamo bisogno del polimorfismo in Java?

Risposta: Il polimorfismo ci permette di avere molte implementazioni per un oggetto. Attraverso il sovraccarico dei metodi, non abbiamo bisogno di troppi metodi con nomi diversi che sono difficili da ricordare. Possiamo invece avere metodi sovraccaricati in modo da avere una chiara implementazione dei metodi che eseguono funzioni simili.

Anche l'override aiuta nella corretta implementazione dell'ereditarietà che ci consente di aggiungere più funzionalità alle classi esistenti in modo più semplice.

D # 2) Cos'è il polimorfismo OOP?

Risposta: La definizione di polimorfismo della programmazione orientata agli oggetti si riferisce alla capacità dei linguaggi di programmazione di implementare un oggetto in varie forme. Il polimorfismo è anche definito come la capacità di un programma di sovrascrivere i metodi dalla classe genitore nella classe derivata per avere funzionalità aggiuntive.

D # 3) Possiamo sovraccaricare e sovrascrivere il metodo principale?

Risposta: No. Non possiamo ignorare il metodo principale statico. Sebbene possiamo sovraccaricare il metodo main, JVM non chiamerà mai il metodo main sovraccaricato. Quindi la risposta migliore è non sovraccaricare o sovrascrivere il metodo principale.

D # 4) I costruttori possono essere sovraccaricati?

Risposta: Sì, possiamo sovraccaricare i costruttori in Java nello stesso modo in cui sovraccarichiamo i metodi Java. I costruttori di solito hanno lo stesso nome ma un numero diverso di argomenti.

D # 5) Perché è utile il sovraccarico del metodo?

Risposta: Possiamo scrivere codice pulito usando il sovraccarico del metodo e diventa anche leggibile poiché abbiamo metodi con lo stesso nome. Quindi, se stiamo implementando funzionalità per vari tipi di dati, possiamo sovraccaricare i metodi e sarà più facile separare il codice.

Conclusione

Il polimorfismo in Java significa che un oggetto può avere molte forme. Il polimorfismo in Java ha due tipi, ovvero polimorfismo in fase di compilazione e polimorfismo runtime. Il polimorfismo in fase di compilazione viene eseguito in fase di compilazione. Il polimorfismo in fase di compilazione è statico e viene implementato tramite il sovraccarico del metodo e il sovraccarico dell'operatore.

Il polimorfismo di runtime viene eseguito in fase di runtime ed è dinamico. Viene implementato utilizzando l'override del metodo.

In questo tutorial, abbiamo visto i modi per implementare il sovraccarico del metodo. Abbiamo anche discusso in dettaglio il sovraccarico degli operatori. Java supporta solo il sovraccarico dell'operatore '+'.

=> Leggere attraverso la serie di formazione Easy Java.

Lettura consigliata

^