TechCodeview

Polymorphisme en Java est un concept par lequel nous pouvons effectuer une action unique de différentes manières . Le polymorphisme est dérivé de 2 mots grecs : poly et morphs. Le mot « poly » signifie plusieurs et « morphes » signifie formes. Le polymorphisme signifie donc plusieurs formes.

Il existe deux types de polymorphisme en Java : le polymorphisme au moment de la compilation et le polymorphisme au moment de l'exécution. Nous pouvons effectuer du polymorphisme en Java par surcharge de méthode et remplacement de méthode.

Si vous surchargez une méthode statique en Java, c'est l'exemple du polymorphisme au moment de la compilation. Ici, nous nous concentrerons sur le polymorphisme d'exécution en Java.

Polymorphisme d'exécution en Java

Polymorphisme d'exécution ou Envoi de méthode dynamique est un processus dans lequel un appel à une méthode remplacée est résolu au moment de l'exécution plutôt qu'au moment de la compilation.

sql sélectionner comme

Dans ce processus, une méthode surchargée est appelée via la variable de référence d'une superclasse. La détermination de la méthode à appeler est basée sur l'objet auquel fait référence la variable de référence.

Comprenons d'abord la conversion ascendante avant le polymorphisme d'exécution.

Diffusion ascendante

Si la variable de référence de la classe Parent fait référence à l’objet de la classe Child, on parle de conversion ascendante. Par exemple:

 class A{} class B extends A{} 

 A a=new B();//upcasting 

Pour la conversion ascendante, nous pouvons utiliser la variable de référence de type classe ou un type d'interface. Par exemple:

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

Ici, la relation de classe B serait :

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

Puisque Object est la classe racine de toutes les classes en Java, nous pouvons donc écrire B IS-A Object.

qu'est-ce qu'une interface

Exemple de polymorphisme d'exécution Java

Dans cet exemple, nous créons deux classes Bike et Splendor. La classe Splendor étend la classe Bike et remplace sa méthode run(). Nous appelons la méthode run par la variable de référence de la classe Parent. Puisqu’elle fait référence à l’objet de sous-classe et que la méthode de sous-classe remplace la méthode de classe Parent, la méthode de sous-classe est invoquée au moment de l’exécution.

Étant donné que l’invocation de méthode est déterminée par la JVM et non par le compilateur, on parle de polymorphisme d’exécution.

 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(); } } 

Sortir:

 running safely with 60km. 

Exemple de polymorphisme d'exécution Java : banque

Considérons un scénario dans lequel Bank est une classe qui fournit une méthode pour obtenir le taux d'intérêt. Cependant, le taux d’intérêt peut différer selon les banques. Par exemple, les banques SBI, ICICI et AXIS proposent des taux d'intérêt de 8,4 %, 7,3 % et 9,7 %.

Remarque : Cet exemple est également donné dans le remplacement de méthode, mais il n'y a pas eu de conversion ascendante.

 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()); } } 

Sortir:

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

Exemple de polymorphisme d'exécution Java : forme

 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(); } } 

Sortir:

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

Exemple de polymorphisme d'exécution Java : animal

 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(); }} 

Sortir:

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

Polymorphisme d'exécution Java avec membre de données

Une méthode est remplacée, pas les données membres, de sorte que le polymorphisme d'exécution ne peut pas être obtenu par les données membres.

Dans l'exemple donné ci-dessous, les deux classes ont une limite de vitesse pour les membres de données. Nous accédons au membre de données par la variable de référence de la classe Parent qui fait référence à l'objet de sous-classe. Puisque nous accédons au membre de données qui n’est pas remplacé, il accédera donc toujours aux données membres de la classe Parent.

Règle : le polymorphisme d'exécution ne peut pas être obtenu par les données membres.

 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 } } 

Sortir:

 90 

Polymorphisme d'exécution Java avec héritage multiniveau

Voyons l'exemple simple du polymorphisme d'exécution avec héritage multiniveau.

chaîne en caractère java

 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(); } } 

Sortir:

 eating eating fruits drinking Milk 

Essayez pour la sortie

 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(); }} 

Sortir:

 Dog is eating 

Puisque BabyDog ne remplace pas la méthode eat(), la méthode eat() de la classe Dog est invoquée.