Polymorphisme d'exécution en Java

Dans cet article, nous allons en apprendre davantage sur le polymorphisme d'exécution en Java. « Poly » signifie « plusieurs » et « morph » signifie « type ». Ainsi, le terme polymorphisme désigne la même chose de types différents. Nous verrons ici comment Java archive le polymorphisme au moment de l'exécution, c'est-à-dire après la compilation mais avant l'exécution du code.

Syntaxe :

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Pour le polymorphisme d'exécution en Java, vous devez suivre la syntaxe de base de Java avec des annotations.

@Override

l'annotation peut être utilisée ici pour indiquer quelle méthode nous souhaitons remplacer spécifiquement.

Comment fonctionne le polymorphisme d'exécution en Java ?

Le polymorphisme d'exécution fonctionne en Java par remplacement de méthode. Le remplacement de méthode se produit lorsque les objets ont le même nom de méthode, les mêmes arguments et le même type que leur classe parent mais avec des fonctionnalités différentes. Si une classe enfant contient ce type de méthode, nous l’appelons une méthode surchargée.

Pourquoi s'appelle-t-on polymorphisme d'exécution ?

Lorsque nous appelons une méthode surchargée d'une classe enfant via sa référence de type parent (ce phénomène en Java est appelé « Upcasting »), alors le type de l'objet indique quelle méthode ou fonctionnalité sera invoquée. La prise de cette décision se produit pendant l'exécution par JVM après la compilation du code. C'est pourquoi on l'appelle polymorphisme d'exécution.

Il est également appelé « Envoi de méthode dynamique ». La raison étant nommée ainsi, car la fonctionnalité de la méthode est décidée dynamiquement au moment de l'exécution selon l'objet par JVM

On l'appelle également « Liaison tardive » car la liaison de la méthode et de l'objet, c'est-à-dire la fonctionnalité de la méthode de l'objet qui sera affichée, est décidée tardivement, c'est-à-dire après la compilation.

Règles et Limitations dans Runtime Polymorphisme

Vous trouverez ci-dessous quelques-unes des règles et limitations du polymorphisme d'exécution :

Règles du polymorphisme d'exécution

• Les méthodes des classes enfant et parent doivent avoir le même nom.
• Les méthodes des classes enfant et parent doivent avoir le même paramètre.
• La relation IS-A est obligatoire (héritage).

Limitations du polymorphisme d'exécution

• On ne peut pas remplacer les méthodes privées d'une classe parent.
• On ne peut pas remplacer les méthodes Final.
• On ne peut pas remplacer les méthodes statiques.

Exemples de polymorphisme d'exécution en Java

 Nous discuterons ici de quelques exemples de code de polymorphisme à l'exécution.

Exemple n°1

Dans cet exemple, nous allons montrer comment la méthode showcase() affiche différents messages selon le type d'objet auquel elle est associée. Lorsqu'il est associé au type « Parents », il affiche les messages d'une classe parent. Lorsqu'il est associé au type « Enfants », il affiche les messages de la classe enfant.

Code :

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

Sortie :

Exemple n°2

Prenons un exemple de polymorphisme d'exécution dans le cas d'un héritage multiniveau. Dans cet exemple, nous avons pris en compte deux niveaux d'héritage. Dans cet exemple, nous allons montrer comment la méthode sip() affiche différents messages selon le type d'objet auquel elle est associée. Lorsqu'il est associé au type « Humain », il affiche les messages d'une classe parent. Lorsqu'il est associé au type « Man », il affiche les messages de sa classe enfant. Toujours au deuxième niveau d'héritage, lorsqu'il est associé au type « Bébé », il affiche les messages de sa classe enfant de son parent, la classe « Homme ».

Code :

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

Sortie :

Exemple n°3

Prenons un autre exemple de polymorphisme d'exécution dans le cas d'un héritage multiniveau. Dans cet exemple, trois niveaux d'héritage sont pris en compte. Dans cet exemple, nous allons montrer comment la méthode feature() affiche différentes fonctionnalités en fonction du type d'objet auquel elle est associée. Lorsqu'il est associé au type « système d'exploitation », il affiche les messages d'une classe parent. Lorsqu'il est associé au type « DOS », il affiche les messages de sa classe enfant. Toujours au deuxième niveau d'héritage, lorsqu'il est associé au type « Windows », il affiche les messages de sa classe enfant de son parent, la classe « DOS ». Toujours au troisième niveau d'héritage, lorsqu'il est associé au type « WindowsMobile », il affiche les messages de sa classe enfant de son parent, la classe « Windows ».

Code :

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

Output:

Conclusion

This concludes our learning of the topic “Runtime Polymorphism in Java”. Write yourself the codes mentioned in the above examples in the java compiler and verify the output. Learning of codes will be incomplete if you will not write code by yourself.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!