Introduzione al polimorfismo di runtime in Java
In questo articolo, impareremo a conoscere il polimorfismo di runtime in Java. "Poly" significa "molti" e "morph" significa "tipo". Quindi il termine polimorfismo indica la stessa cosa di diversi tipi. Qui vedremo come Java archivia il polimorfismo in fase di esecuzione, il che significa che dopo la compilazione ma prima dell'esecuzione del codice.
Sintassi:
Per il polimorfismo di runtime in Java, è necessario seguire la sintassi di base di Java con annotazioni. @Override annotazione @Override può essere utilizzata qui per indicare in modo specifico quale metodo vogliamo sovrascrivere.
Come funziona il polimorfismo di runtime in Java?
Il polimorfismo di runtime funziona in Java mediante l'override del metodo. La sostituzione del metodo si verifica quando gli oggetti hanno lo stesso nome e argomenti e tipo di metodo della sua classe padre ma con funzionalità diverse. Se una classe figlio contiene quel tipo di metodo, la chiamiamo un metodo ignorato.
Perché si chiama polimorfismo di runtime?
quando chiamiamo un metodo ignorato di classe figlio attraverso il suo riferimento al tipo genitore (questo fenomeno in java è indicato come "Upcasting"), allora il tipo di oggetto indica quale metodo o funzionalità verrà invocato. La presa di questa decisione avviene durante l'esecuzione da parte di JVM dopo la compilazione del codice. Quindi si chiama polimorfismo di runtime.
Viene anche definito "Invio di metodo dinamico". Il motivo viene chiamato così, a causa del fatto che la funzionalità del metodo viene decisa in modo dinamico in fase di esecuzione secondo l'oggetto da JVM
Si chiama anche "Late binding", perché l'associazione di metodo e oggetto, il che significa che la funzionalità di quale metodo dell'oggetto verrà visualizzato, viene decisa in ritardo, cioè dopo la compilazione.
Regole e limitazioni in Runtim e Polymorphism
Di seguito sono riportate alcune regole e limitazioni del polimorfismo di runtime:
Polimorfismo delle regole di runtime
- I metodi della classe figlio e genitore devono avere lo stesso nome.
- I metodi di classe figlio e genitore devono avere lo stesso parametro.
- La relazione IS-A è obbligatoria (eredità).
Limitazioni del polimorfismo di runtime
- Non è possibile ignorare i metodi privati di una classe genitore.
- Non è possibile ignorare i metodi finali.
- Non è possibile ignorare i metodi statici.
Esempi di polimorfismo di runtime in Java
Discuteremo alcuni esempi di codice del polimorfismo di runtime qui.
Esempio 1
In questo esempio, mostreremo come il metodo showcase () sta visualizzando messaggi diversi a seconda del tipo di oggetto a cui è associato. Quando è associato al tipo "Genitori", mostra i messaggi dalla classe genitore. Considerando che, quando è associato al tipo "Bambini", sta mostrando messaggi da classe figlio.
Codice:
class Parents (
public void showcase () (
System.out.println("I am Parent");
)
)
class Children extends Parents (
@Override
public void showcase () (
System.out.println("I am Children");
)
)
public class RunTimePolymorphism (
public static void main(String args()) (
Parents superObject = new Parents();
superObject.showcase(); //method of super class or parent class is called
Parents subObject = new Children(); // upcasting
subObject.showcase();//method of sub class or child class is called by Parent reference, this is called "Run time Polymorphism"
Children subObject2 = new Children();
subObject2.showcase(); //method of sub class or child class is called
)
)
Produzione:
Esempio n. 2
Facciamo un esempio di polimorfismo di runtime in caso di eredità multilivello. In questo esempio, abbiamo preso in considerazione due livelli di eredità. In questo esempio, mostreremo come il metodo sip () sta visualizzando messaggi diversi a seconda del tipo di oggetto a cui è associato. Quando è associato al tipo "Umano", mostra i messaggi di una classe genitore. Mentre, quando è associato al tipo "Man", mostra i messaggi della sua classe figlio. Sempre nel secondo livello di eredità, quando è associato al tipo "Baby", mostra i messaggi della sua classe figlio del suo genitore che è la classe "Man".
Codice:
class Human(
void sip() (
System.out.println("Human is sipping");
)
)
class Man extends Human(
void sip()(
System.out.println("Man is sipping soup");
)
)
class Baby extends Man(
void sip()(
System.out.println("Baby is sipping milk");
)
)
public class RunTimePolymorphism (
public static void main(String args())(
Human superObject=new Human();
Human subObject=new Man(); // // upcasting : first level of heritance
Human babyObject=new Baby(); // // upcasting : second level of heritance
superObject.sip();
subObject.sip(); //run time polymorphism happening in first level of heritance
babyObject.sip(); //run time polymorphism happening in second level of heritance
)
)
Produzione:
Esempio n. 3
Facciamo un altro esempio di polimorfismo di runtime in caso di eredità multilivello. In questo esempio abbiamo preso in considerazione tre livelli di ereditarietà. In questo esempio, mostreremo come la funzione method () sta mostrando diverse funzionalità a seconda del tipo di oggetto a cui è associata. Quando è associato al tipo di "sistema operativo", mostra i messaggi di una classe superiore. Mentre, quando è associato al tipo "DOS", mostra i messaggi della sua classe figlio. Sempre nel secondo livello di ereditarietà, quando è associato al tipo "Windows", mostra i messaggi della sua classe figlio del suo genitore che è la classe "DOS". Sempre nel terzo livello di ereditarietà, quando è associato al tipo "WindowsMobile", mostra i messaggi della sua classe figlio del suo genitore che è la classe "Windows".
Codice:
class OperatingSytem(
void feature() (
System.out.println("This is Operating Sytem");
)
)
class DOS extends OperatingSytem(
void feature()(
System.out.println("This is DOS");
)
)
class Windows extends DOS(
void feature()(
System.out.println("This is Windows");
)
)
class WindowsMobile extends Windows(
void feature()(
System.out.println("This is Windows Mobile");
)
)
public class RunTimePolymorphism (
public static void main(String args())(
OperatingSytem superObject=new OperatingSytem();
OperatingSytem subObject=new DOS(); // child object type : first level of heritance
OperatingSytem sub2Object=new Windows(); // child object type : second level of heritance
OperatingSytem sub3Object=new WindowsMobile(); // child object type : third level of heritance
superObject.feature();
subObject.feature(); //run time polymorphism happening in first level of heritance
sub2Object.feature(); //run time polymorphism happening in second level of heritance
sub3Object.feature(); //run time polymorphism happening in third level of heritance
)
)
Produzione:
Conclusione
Questo conclude il nostro apprendimento dell'argomento "Runtime Polymorphism in Java". Scrivi tu stesso i codici menzionati negli esempi sopra nel compilatore java e verifica l'output. L'apprendimento dei codici sarà incompleto se non scriverai il codice da solo.
Articoli consigliati
Questa è stata una guida al polimorfismo di runtime in Java. Qui discutiamo di come funziona il polimorfismo di runtime in Java con esempi. Puoi anche dare un'occhiata ai seguenti articoli per saperne di più -
- Parola chiave statica in Java
- Sostituzione in Java
- Che cos'è il polimorfismo?
- Rust vs Golang