Nell’ultimo tutorial abbiamo discusso Polimorfismo in Java. In questa guida vedremo tipi di polimorfismo. Esistono due tipi di polimorfismo in java:
1) Polimorfismo statico noto anche come polimorfismo a tempo di compilazione
2) Polimorfismo dinamico noto anche come polimorfismo runtime
Polimorfismo a tempo di compilazione (o polimorfismo statico)
Il polimorfismo che viene risolto durante il tempo del compilatore è noto come polimorfismo statico. L’overloading del metodo è un esempio di polimorfismo del tempo di compilazione.
Overloading del metodo: questo ci consente di avere più di un metodo con lo stesso nome, se i parametri dei metodi sono diversi per numero, sequenza e tipi di dati di parametri. Abbiamo già discusso l’overloading del metodo qui: Se non hai letto quella guida, fai riferimento: Overloading del metodo in Java
Esempio di polimorfismo statico
L’overloading del metodo è uno dei modi in cui java supporta il polimorfismo statico. Qui abbiamo due definizioni dello stesso metodo add () che il metodo add verrebbe chiamato è determinato dall’elenco dei parametri al momento della compilazione. Questo è il motivo per cui questo è anche noto come polimorfismo del tempo di compilazione.
class SimpleCalculator{ int add(int a, int b) { return a+b; } int add(int a, int b, int c) { return a+b+c; }}public class Demo{ public static void main(String args) { SimpleCalculator obj = new SimpleCalculator(); System.out.println(obj.add(10, 20)); System.out.println(obj.add(10, 20, 30)); }}
Uscita:
3060
Polimorfismo di runtime (o polimorfismo dinamico)
È anche noto come Invio dinamico del metodo. Il polimorfismo dinamico è un processo in cui una chiamata a un metodo sovrascritto viene risolta in fase di runtime, ecco perché viene chiamato polimorfismo di runtime. Ho già discusso l’override del metodo in dettaglio in un tutorial separato, riferiscilo: Override del metodo in Java.
Esempio
In questo esempio abbiamo due classi ABC e XYZ. ABC è una classe genitore e XYZ è una classe figlio. La classe figlio sta sovrascrivendo il metodo myMethod () della classe genitore. In questo esempio abbiamo un oggetto di classe figlio assegnato al riferimento di classe genitore, quindi per determinare quale metodo verrà chiamato, il tipo di oggetto verrà determinato in fase di esecuzione. È il tipo di oggetto che determina quale versione del metodo verrà chiamata (non il tipo di riferimento).
Per comprendere il concetto di override, dovresti avere le conoscenze di base dell’ereditarietà in Java.
class ABC{ public void myMethod(){System.out.println("Overridden Method"); }}public class XYZ extends ABC{ public void myMethod(){System.out.println("Overriding Method"); } public static void main(String args){ABC obj = new XYZ();obj.myMethod(); }}
Uscita:
Overriding Method
Quando un metodo sovrascritto viene chiamato attraverso un riferimento di classe padre, quindi tipo dell’oggetto determina quale metodo deve essere eseguito. Pertanto, questa determinazione viene effettuata in fase di esecuzione.
Poiché entrambe le classi, la classe figlio e la classe genitore hanno lo stesso metodo animalSound. Quale versione del metodo(classe figlio o classe genitore) verrà chiamata è determinata in fase di esecuzione da JVM.
Alcuni esempi più importanti:
ABC obj = new ABC();obj.myMethod();// This would call the myMethod() of parent class ABCXYZ obj = new XYZ();obj.myMethod();// This would call the myMethod() of child class XYZABC obj = new XYZ();obj.myMethod();// This would call the myMethod() of child class XYZ
Nel terzo caso il metodo della classe figlio deve essere eseguito perché quale metodo deve essere eseguito è determinato dal tipo di oggetto e poiché l’oggetto appartiene alla classe figlio, viene chiamata la versione della classe figlio di myMethod ().