Introduction au 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 indique la même chose de différents types. Nous verrons ici comment Java archive le polymorphisme au moment de l'exécution, ce qui signifie, après la compilation mais avant l'exécution du code.
Syntaxe:
Pour le polymorphisme d'exécution en Java, vous devez suivre la syntaxe de base de java avec des annotations. @Override annotation @Override peut être utilisée ici pour indiquer précisément quelle méthode nous voulons remplacer.
Comment fonctionne le polymorphisme d'exécution en Java?
Le polymorphisme d'exécution fonctionne en Java par substitution de méthode. La substitution 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 ceux de sa 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 redéfinie.
Pourquoi est-il appelé polymorphisme d'exécution?
lorsque nous appelons une méthode redéfinie de classe enfant via sa référence de type parent (ce phénomène en java est appelé «Upcasting»), le type de l'objet indique quelle méthode ou fonctionnalité sera invoquée. Cette décision se produit pendant l'exécution par JVM après la compilation du code. Par conséquent, il est appelé polymorphisme d'exécution.
Il est également appelé «envoi de méthode dynamique». Raison étant nommée ainsi, du fait que la fonctionnalité de la méthode est décidée dynamiquement lors de l'exécution selon l'objet par JVM
Il est également appelé «liaison tardive», car la liaison de la méthode et de l'objet, ce qui signifie que la fonctionnalité de la méthode de l'objet sera affichée, est décidée tardivement, c'est-à-dire après la compilation.
Règles et limitations dans Runtim e Polymorphism
Voici quelques règles et limitations du polymorphisme d'exécution:
Règles de polymorphisme d'exécution
- Les méthodes des classes enfant et parent doivent porter 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).
Limites 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 finales.
- On ne peut pas remplacer les méthodes statiques.
Exemples de polymorphisme d'exécution en Java
Nous allons discuter ici de quelques exemples de code de polymorphisme d'exécution.
Exemple 1
Dans cet exemple, nous allons montrer comment la méthode showcase () affiche différents messages en fonction du type d'objet auquel elle est associée. Lorsqu'il est associé au type «Parents», il affiche des messages de la classe parent. Alors que, lorsqu'il est associé au type «Enfants», il affiche des messages de 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
)
)
Production:
Exemple # 2
Prenons un exemple de polymorphisme d'exécution en cas d'héritage à plusieurs niveaux. 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 en fonction du type d'objet auquel elle est associée. Lorsqu'il est associé au type «Humain», il affiche des messages d'une classe parente. Alors que, lorsqu'il est associé au type «Man», il affiche des messages de sa classe enfant. Toujours dans le deuxième niveau d'héritage, lorsqu'il est associé au type "Baby", il affiche des messages de sa classe enfant de son parent qui est la classe "Man".
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
)
)
Production:
Exemple # 3
Prenons un autre exemple de polymorphisme d'exécution en cas d'héritage à plusieurs niveaux. Dans cet exemple, nous avons trois niveaux d'héritage 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 parente. Alors que, lorsqu'il est associé au type «DOS», il affiche des messages de sa classe enfant. Toujours dans le deuxième niveau d'héritage, lorsqu'il est associé au type «Windows», il affiche les messages de sa classe enfant de son parent qui est la classe «DOS». Toujours dans le troisième niveau d'héritage, lorsqu'il est associé au type «WindowsMobile», il affiche les messages de sa classe enfant de son parent qui est 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
)
)
Production:
Conclusion
Ceci conclut notre apprentissage du sujet «Polymorphisme d'exécution en Java». Écrivez-vous les codes mentionnés dans les exemples ci-dessus dans le compilateur java et vérifiez la sortie. L'apprentissage des codes sera incomplet si vous n'écrivez pas de code par vous-même.
Articles recommandés
Cela a été un guide sur le polymorphisme d'exécution en Java. Nous discutons ici du fonctionnement du polymorphisme d'exécution en java avec des exemples. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Mot-clé statique en Java
- Surcharge en Java
- Qu'est-ce que le polymorphisme?
- Rust vs Golang