Polimorfismo in Java è un concetto mediante il quale possiamo eseguire a singola azione in modi diversi . Il polimorfismo deriva da 2 parole greche: poly e morphs. La parola 'poli' significa molti e 'morfosi' significa forme. Quindi polimorfismo significa molte forme.

Esistono due tipi di polimorfismo in Java: polimorfismo in fase di compilazione e polimorfismo in fase di esecuzione. Possiamo eseguire il polimorfismo in Java mediante sovraccarico del metodo e override del metodo.

ottieni la lunghezza dell'array in c

Se sovraccarichi un metodo statico in Java, è l'esempio del polimorfismo in fase di compilazione. Qui ci concentreremo sul polimorfismo di runtime in Java.

Polimorfismo runtime in Java

Polimorfismo di runtime O Invio del metodo dinamico è un processo in cui una chiamata a un metodo sottoposto a override viene risolta in fase di esecuzione anziché in fase di compilazione.

In questo processo, un metodo sottoposto a override viene chiamato tramite la variabile di riferimento di una superclasse. La determinazione del metodo da chiamare si basa sull'oggetto a cui fa riferimento la variabile di riferimento.

Comprendiamo prima l'upcasting prima del polimorfismo di runtime.

Upcasting

Se la variabile di riferimento della classe Parent si riferisce all'oggetto della classe Child, è noto come upcasting. Per esempio:

 class A{} class B extends A{} 

 A a=new B();//upcasting 

Per l'upcasting, possiamo utilizzare la variabile di riferimento del tipo di classe o del tipo di interfaccia. Per esempio:

 interface I{} class A{} class B extends A implements I{} 

Qui, la relazione della classe B sarebbe:

 B IS-A A B IS-A I B IS-A Object 

Poiché Object è la classe radice di tutte le classi in Java, possiamo scrivere B IS-A Object.

coppia C++

Esempio di polimorfismo Java Runtime

In questo esempio, stiamo creando due classi Bike e Splendor. La classe Splendor estende la classe Bike e sovrascrive il suo metodo run(). Stiamo chiamando il metodo run tramite la variabile di riferimento della classe Parent. Poiché si riferisce all'oggetto della sottoclasse e il metodo della sottoclasse sovrascrive il metodo della classe Parent, il metodo della sottoclasse viene richiamato in fase di esecuzione.

Poiché l'invocazione del metodo è determinata dalla JVM e non dal compilatore, è nota come polimorfismo di runtime.

 class Bike{ void run(){System.out.println('running');} } class Splendor extends Bike{ void run(){System.out.println('running safely with 60km');} public static void main(String args[]){ Bike b = new Splendor();//upcasting b.run(); } } 

Produzione:

percorso impostato in Java

 running safely with 60km. 

Esempio di polimorfismo Java Runtime: Bank

Consideriamo uno scenario in cui Bank è una classe che fornisce un metodo per ottenere il tasso di interesse. Tuttavia, il tasso di interesse può variare a seconda delle banche. Ad esempio, le banche SBI, ICICI e AXIS offrono tassi di interesse dell'8,4%, 7,3% e 9,7%.

Nota: questo esempio viene fornito anche nell'override del metodo ma non è stato effettuato l'upcasting.

 class Bank{ float getRateOfInterest(){return 0;} } class SBI extends Bank{ float getRateOfInterest(){return 8.4f;} } class ICICI extends Bank{ float getRateOfInterest(){return 7.3f;} } class AXIS extends Bank{ float getRateOfInterest(){return 9.7f;} } class TestPolymorphism{ public static void main(String args[]){ Bank b; b=new SBI(); System.out.println('SBI Rate of Interest: '+b.getRateOfInterest()); b=new ICICI(); System.out.println('ICICI Rate of Interest: '+b.getRateOfInterest()); b=new AXIS(); System.out.println('AXIS Rate of Interest: '+b.getRateOfInterest()); } } 

Produzione:

 SBI Rate of Interest: 8.4 ICICI Rate of Interest: 7.3 AXIS Rate of Interest: 9.7 

Esempio di polimorfismo Java Runtime: forma

 class Shape{ void draw(){System.out.println('drawing...');} } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle...');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle...');} } class Triangle extends Shape{ void draw(){System.out.println('drawing triangle...');} } class TestPolymorphism2{ public static void main(String args[]){ Shape s; s=new Rectangle(); s.draw(); s=new Circle(); s.draw(); s=new Triangle(); s.draw(); } } 

Produzione:

 drawing rectangle... drawing circle... drawing triangle... 

Esempio di polimorfismo runtime Java: animale

 class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void eat(){System.out.println('eating bread...');} } class Cat extends Animal{ void eat(){System.out.println('eating rat...');} } class Lion extends Animal{ void eat(){System.out.println('eating meat...');} } class TestPolymorphism3{ public static void main(String[] args){ Animal a; a=new Dog(); a.eat(); a=new Cat(); a.eat(); a=new Lion(); a.eat(); }} 

Produzione:

 eating bread... eating rat... eating meat... 

Polimorfismo Java Runtime con membro dati

Viene eseguito l'override di un metodo, non dei membri dati, quindi il polimorfismo di runtime non può essere ottenuto dai membri dati.

Nell'esempio riportato di seguito, entrambe le classi hanno uno speedlimit del membro dati. Stiamo accedendo al membro dati tramite la variabile di riferimento della classe Parent che si riferisce all'oggetto sottoclasse. Poiché stiamo accedendo al membro dati che non è sovrascritto, quindi accederà sempre al membro dati della classe Parent.

Regola: il polimorfismo di runtime non può essere ottenuto dai membri dati.

 class Bike{ int speedlimit=90; } class Honda3 extends Bike{ int speedlimit=150; public static void main(String args[]){ Bike obj=new Honda3(); System.out.println(obj.speedlimit);//90 } } 

Produzione:

 90 

Polimorfismo Java Runtime con ereditarietà multilivello

Vediamo il semplice esempio di Runtime Polymorphism con ereditarietà multilivello.

dimensioni del testo in lattice

 class Animal{ void eat(){System.out.println('eating');} } class Dog extends Animal{ void eat(){System.out.println('eating fruits');} } class BabyDog extends Dog{ void eat(){System.out.println('drinking milk');} public static void main(String args[]){ Animal a1,a2,a3; a1=new Animal(); a2=new Dog(); a3=new BabyDog(); a1.eat(); a2.eat(); a3.eat(); } } 

Produzione:

 eating eating fruits drinking Milk 

Prova per l'output

 class Animal{ void eat(){System.out.println('animal is eating...');} } class Dog extends Animal{ void eat(){System.out.println('dog is eating...');} } class BabyDog1 extends Dog{ public static void main(String args[]){ Animal a=new BabyDog1(); a.eat(); }} 

Produzione:

 Dog is eating 

Poiché BabyDog non sovrascrive il metodo eat(), viene richiamato il metodo eat() della classe Dog.