Types de polymorphisme en Java | Expliqué

Le polymorphisme est une capacité qui permet à un objet de transporter de nombreuses formes ou en mots simples, il nous permet de créer pour effectuer une seule tâche de diverses manières. Par exemple, le polymorphisme nous permet de créer plusieurs méthodes avec le même nom, mais l'implémentation de chaque méthode sera différente de l'autre méthode. En Java, le concept de polymorphisme peut être mis en œuvre dans l'exécution ou en temps de compilation.

Cet article présente un aperçu approfondi des types de polymorphisme comme indiqué ci-dessous:

• Qu'est-ce que le polymorphisme en Java
• Polymorphisme statique / temps de compilation en java
• Polymorphisme dynamique / d'exécution en Java

Alors, commençons!

Qu'est-ce que le polymorphisme en Java

Le mot polymorphisme est une combinaison de deux mots grecs poly signifie beaucoup et transactions signifie que les formes sont donc combinées le mot polymorphisme moyens plusieurs / plusieurs formulaires. Le polymorphisme nous permet d'effectuer une tâche spécifique de diverses manières

Exemple

Prenons les exemples du monde réel répertorié ci-dessous pour comprendre le concept de polymorphisme:

Les animaux sonnent: Lion rugit, les aboiements de chien, les quartiers de cheval, etc.

Maintenant, comprenons le concept ci-dessus en termes de programmation Java, dans cet exemple, le Animaux est une classe, et "des sons()" est sa méthode:

Ici Animaux est une classe générale qui ne peut pas être restreinte avec un seul sons comme un rugissement, ou une écorce, etc. Ainsi, une classe aura une implémentation générique qui peut être étendue par les autres classes.

En outre, Lion, Chien, et Cheval (sous-classes) peut étendre les propriétés de la classe parentale Animal. Les classes d'enfants hériteront de la fonction de leur classe de parents et pourront remplacer la mise en œuvre de cette fonction.

Ainsi, le polymorphisme en Java vous permet d'utiliser la même méthode pour effectuer diverses fonctionnalités. En Java, le polymorphisme peut être réalisé au moyen d'un temps de compilation ou d'exécution.

Polymorphisme statique / temps de compilation en java

Dans le polymorphisme à temps de compilation, les objets de CALSS sont limités avec les méthodes au moment de la compilation. Le polymorphisme à temps de compilation est géré par le compilateur et il prend en charge le concept de surcharge de méthode.

La surcharge de méthode dans le polymorphisme de compilation-temps permet à une classe de créer plusieurs méthodes avec le même nom mais des implémentations différentes en termes de paramètres. Et il existe des règles pour ces paramètres comme indiqué ci-dessous:

Nous pouvons créer plusieurs méthodes avec le même nom mais avec une séquence / ordre de paramètres différent.

Nous pouvons créer plus d'une méthode avec le même nom mais avec différents types de données de paramètres:

Nous pouvons créer plusieurs méthodes avec le même nom mais avec un nombre différent de paramètres.

Voyons un exemple pour la profonde compréhension du polymorphisme à temps de compilation:

Exemple

Dans cet exemple, nous avons créé deux classes:

Multiplication.Java

Le Multiplication La classe crée trois méthodes avec le même nom "produit()", La première méthode prend deux valeurs entières, la seconde prend deux valeurs doubles et la troisième prend trois valeurs entières:

package principal;
Multiplication de classe publique
Int Product (int num1, int num2)
retour num1 * num2;

Double produit (double num1, double num2)
retour num1 * num2;

int produit int (int num1, int num2, int num3)
return num1 * num2 * num3;

La capture d'écran du code ci-dessus sera comme ceci:

Principal.Java

Dans Principal classe, nous avons créé l'objet de la classe de multiplication et appelé les trois méthodes du Multiplication classe:

package principal;
classe publique Main
public static void main (String [] args)
Multiplication obj = nouvelle multiplication ();
Système.dehors.println ("Résultat de deux valeurs int:" + obj.produit (5, 12));
Système.dehors.println ("Résultat de trois valeurs int:" + obj.produit (4, 15, 2));
Système.dehors.println ("Résultat des doubles valeurs:" + obj.produit (5.5, 2.67));

Le code complet du Principal La classe est présentée dans la figure suivante:

La sortie ira comme ceci:

À partir de la sortie ci-dessus, nous observons que:

Quand nous avons passé les deux int valeurs alors le produit Méthode en ayant deux int Les paramètres sont exécutés.

Quand nous avons passé les trois int valeurs alors le produit Méthode en ayant trois int Les paramètres sont exécutés.

De même, lorsque nous avons dépassé les deux double valeurs alors le produit Méthode en ayant deux double Les paramètres sont exécutés.

Polymorphisme dynamique / d'exécution en Java

Dans Durée Polymorphisme, les objets sont limités avec les méthodes à l'exécution (liaison dynamique). Le polymorphisme dynamique ou d'exécution soutient le concept de Méthode remplacée.

• Dans la POO, le terme primordial se réfère qui remplacer les fonctionnalités des méthodes existantes.
• Dans le polymorphisme d'exécution, le type et la liste du paramètre doivent être les mêmes dans la méthode remplacée.
• Le type de retour de la méthode doit être le même dans la superclasse et la sous-classe.
• Une classe de parents ayant une méthode déclarée avec finale, privée ou statique ne peut pas être remplacée dans la sous-classe, mais une méthode statique peut être redéclarée dans la classe infantile.

Jetons un coup d'œil à l'exemple ci-dessous pour la profonde compréhension du polymorphisme d'exécution.

Exemple

L'extrait de code ci-dessous crée trois classes: Personne, employé, et Département, le Personne La classe est une classe parent, le Employé La classe s'étend Personne classe et Département La classe entend Employé classe.

classe de classe
public void print ()
Système.dehors.println ("Ceci est une classe de personne");


L'employé de classe étend la personne
public void print ()
Système.dehors.println ("Ceci est une classe d'employés");


Le département de classe étend les employés
public void print ()
Système.dehors.println ("Ceci est le département");


classe publique RuntimeExample
public static void main (String [] args)
Personne per = new personne ();
Personne EMP = nouvel employé ();
Person Dept = New Department ();
par.imprimer();
empiler.imprimer();
département.imprimer();

Les classes d'enfants étendent le imprimer() Méthode de leurs classes de parents et ils ont également leur propre implémentation de cette méthode print (). Et dans la méthode principale, nous créons l'objet de chaque classe et appelons le imprimer() Méthode avec l'objet de classe respectif. Le code complet et la sortie sont fournis dans la capture d'écran suivante:

La sortie ci-dessus vérifie que lorsque nous appelons les fonctions d'impression avec chaque objet de classe d'enfants, ils remplacent l'implémentation de la fonction Parent Class Print ().

Conclusion

Le polymorphisme nous permet de créer plusieurs méthodes avec le même nom mais avec différentes implémentations dans les classes parentales et enfants. Il peut être réalisé soit au moment de la compilation, qui prend en charge le concept de surcharge de méthode ou à l'exécution qui prend en charge le concept de remplacement. Cet article présente un aperçu détaillé du polymorphisme d'exécution et de compilation et il explique ce qu'est le polymorphisme, ses types et les règles pour mettre en œuvre chaque type.