what is polymorphism java tutorial with examples
Ce tutoriel explique ce qu'est le polymorphisme en Java, les types de polymorphisme et comment implémenter le polymorphisme à la compilation avec des exemples:
Le mot «polymorphisme» dérive de deux mots, à savoir 'Poly' ce qui signifie beaucoup et ' morphes »Signifiant des formes. Ainsi, le polymorphisme signifie de nombreuses formes. Dans un langage de programmation, nous pouvons dire qu'un objet peut prendre plusieurs formes, et donc l'objet est polymorphe.
Le polymorphisme est l'une des caractéristiques les plus importantes de la POO et il nous permet d'exprimer une caractéristique (un objet ou un message ou une méthode ou un opérateur) sous diverses formes.
=> Jetez un œil au guide du débutant Java ici.
Ce que vous apprendrez:
Introduction au polymorphisme en Java
L'entité polymorphe se comporte différemment selon différents scénarios.
Par exemple, considérez un opérateur «+» (addition) en Java. Il s'agit d'un opérateur binaire et prend deux opérandes. Lorsque les opérandes passés à l’opérateur «+» sont des nombres, une opération d’addition qui renvoie la somme de deux nombres est effectuée.
Lorsque les opérandes sont de type String, l’opérateur «+» n’ajoute pas les objets String, mais concatène ou joint le contenu de la chaîne pour former une troisième chaîne résultante.
Par exemple, si ' un ' et ' deux ”Sont le contenu de deux objets String alors 'Un' + 'deux' aura pour résultat ' un deux ». C'est la concaténation.
En Java, tous les objets sont polymorphes car ils sont tous dérivés de la classe «Object» et remplissent ainsi la relation «IS-A» avec la classe Object.
Un objet est toujours accessible via une variable de référence de ce type de classe particulier. Une fois qu'une variable de référence d'un type particulier est déclarée, elle ne peut pas être modifiée. Cependant, si la variable de référence n’est pas déclarée comme «finale», nous pouvons la réaffecter pour pointer vers d’autres objets.
oracle sql interroge questions et réponses pour les pdf expérimentés
Le type de cette référence d'objet décidera des méthodes de classe ou des fonctions à appeler.
Par exemple,s'il existe une classe ABC et une classe XYZ dérivées de ABC, les deux classes ont une méthode polymorphe func ().
class ABC{ void func(){} } class XYZ extends ABC{ void func() {} }
Créons une référence de type ABC.
obj = new XYZ ();
Maintenant, lorsque nous appelons la méthode func (), puisque l'objet pointé par obj est de classe XYZ, la méthode func () de la classe XYZ sera appelée.
Comme nous l'avons vu dans l'exemple ci-dessus, la méthode func () a différentes implémentations mais le même prototype. En fonction de l'objet pointé par l'objet de référence, nous avons la mise en œuvre appropriée dans ce scénario appelée. C'est du polymorphisme.
Parlons en détail du polymorphisme en Java.
Exemple de polymorphisme Java
Voyons un exemple simple de polymorphisme en Java avec l’opération d’addition comme indiqué précédemment.
Ici, nous utilisons deux méthodes avec le même nom mais des paramètres différents. La première fonction accepte deux paramètres entiers et la seconde méthode accepte deux paramètres de chaîne.
Selon le type de paramètres transmis, la méthode appropriée est appelée et ajoute deux entiers et imprime le résultat ou concatène les deux chaînes et imprime la chaîne résultante.
Le programme Java est donné ci-dessous:
class Addition_operation{ //method to add two integers void addition_func(int num1,int num2){ System.out.println('ABC::addition_func:' + (num1+num2)); } //overloaded method to add two strings void addition_func(String str1, String str2){ String result = str1 + ' ' + str2; System.out.println('XYZ::addition_func:' + result); } } public class Main { public static void main(String[] args) { Addition_operation abc = new Addition_operation(); //create a class object abc.addition_func (3,4); //calls 1st method abc.addition_func ('Hello' , 'World!'); //calls 2nd method } }
Production:
Ici, nous avons vu que lorsque la première fois que nous passons deux paramètres entiers à addition_func, la première méthode est appelée. Dans le deuxième appel de fonction, nous transmettons deux paramètres de type String, et par conséquent, la deuxième méthode surchargée est appelée.
Types de polymorphisme
Java prend en charge deux types de polymorphisme:
- Polymorphisme à la compilation
- Polymorphisme d'exécution
Comme son nom l'indique, le polymorphisme à la compilation est effectué au moment de la compilation et le polymorphisme à l'exécution est effectué à l'exécution.
Comme le montre la figure ci-dessus, le polymorphisme au moment de la compilation est implémenté via la surcharge. Nous pouvons surcharger soit la méthode, soit l'opérateur. Le polymorphisme d'exécution est obtenu par le remplacement.
Dans ce didacticiel, nous aborderons en détail le polymorphisme à la compilation. Nous aborderons le polymorphisme d'exécution dans le prochain tutoriel.
Polymorphisme à la compilation en Java
Le polymorphisme à la compilation est également connu sous le nom de «polymorphisme statique». Dans le cadre du polymorphisme à la compilation, quel que soit le polymorphisme à effectuer, il est effectué au moment de la compilation.
En Java, le polymorphisme à la compilation est effectué en utilisant ' Surcharge de méthode ». En utilisant la surcharge de méthode, nous pouvons avoir une ou plusieurs méthodes avec le même nom et uniquement différenciées sur les nombres ou le type ou l'ordre des paramètres.
La surcharge de méthode est l'implémentation la plus courante du polymorphisme à la compilation en Java. Java prend également en charge la surcharge des opérateurs.
Qu'est-ce que la surcharge en Java en général?
La surcharge en Java est un processus consistant à avoir plus d'une méthode avec le même nom et le même type de retour mais différant sur la séquence, le nombre et les types d'arguments. Il est également appelé surcharge de méthode en général.
Surcharge de méthode en Java
La surcharge de méthode est une implémentation du polymorphisme à la compilation en Java. Lorsque nous avons une ou plusieurs méthodes avec le même nom et / ou des types de retour mais des listes de paramètres différentes, alors nous disons que nous avons «surchargé» les méthodes.
Ainsi, dans une classe donnée, nous pouvons avoir différentes méthodes avec le même nom mais des listes d'arguments différentes.
Comment invoquer des méthodes surchargées? Ou comment le compilateur sait-il quelle méthode doit être appelée?
L'appel de la méthode exacte qui correspond à l'appel est effectué en fonction de la liste de paramètres.
Nous avons déjà vu qu'une classe en Java peut avoir plus d'un constructeur. Dans le cas des constructeurs, la liste des arguments ou les arguments acceptés par le constructeur sont différents dans tous les constructeurs. Ceci est un exemple de surcharge. La surcharge du constructeur est donc une forme basique de surcharge de méthode en Java.
Voyons maintenant comment surcharger une méthode en Java?
Java propose trois méthodes de surcharge de méthode en fonction des variations de la liste des paramètres / arguments.
# 1) Type de paramètres
Nous pouvons surcharger les méthodes en Java en fonction du type de données des paramètres.
Prenons l'exemple suivant dans lequel nous avons donné des prototypes de trois méthodes.
addition (int, int);
addition (int, float);
addition (chaîne, chaîne);
Comme vu ci-dessus, nous avons le même nom de méthode dans les trois cas et le même nombre de paramètres, mais chaque appel de méthode a différents types de paramètres.
Donc, tant que les méthodes ont différents types de paramètres, on peut dire que les méthodes sont surchargées. Lorsque nous appelons la méthode, le compilateur décide du type de données du paramètre et, en fonction du type de données de la liste de paramètres fournie avec l'appel de méthode, la méthode appropriée est appelée.
Par exemple,si nous avons un appel de méthode comme ci-dessous:
addition (3, 3,5);
Dans l'appel de méthode ci-dessus, nous pouvons voir que le premier paramètre est de type int tandis que le deuxième paramètre est de type float. Lorsque l'appel ci-dessus est rencontré, le compilateur résout la liste de paramètres, puis appelle la méthode appropriée qui est la deuxième méthode ci-dessus.
Implémentons maintenant un programme Java complet pour illustrer la surcharge de méthode en fonction des types de données des paramètres.
quelle est la qualité d'ubuntu par rapport à Windows
class MethodOverload { //overloaded method - char parameter public void printParam(char ch) { System.out.println('Input character:' + ch); } //overloaded method - int parameter public void printParam(int num) { System.out.println('Input Number:' + num); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (char ) obj.printParam(10); //call overloaded method (int ) } }
Production:
# 2) Nombre de paramètres
Une autre implémentation de la surcharge de méthode consiste à surcharger les méthodes avec un nombre différent de paramètres dans l'appel de fonction.
Par exemple,considérons les déclarations de méthode suivantes:
addnum (int, int);
addnum (int, int, int);
Dans les déclarations de méthode ci-dessus, la première déclaration de méthode a deux paramètres et la deuxième déclaration a trois paramètres. Lorsqu'une fonction est appelée, le compilateur inspecte le nombre de paramètres, puis résout l'appel de méthode de manière appropriée.
L'exemple ci-dessous montre le programme qui utilise la surcharge de méthode en fonction du nombre de paramètres.
class MethodOverload { //overloaded method - 1 parameter public void printParam(char ch) { System.out.println(ch); } //overloaded method - 2 parameters public void printParam(char ch, int num) { System.out.println('Character: ' + ch + ' ; '+ 'Number:' +num); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (1 ) obj.printParam('A',10); //call overloaded method (2 ) } }
Production:
Dans cet exemple, nous avons deux méthodes surchargées en fonction du nombre de paramètres. La première méthode prend un paramètre et la deuxième méthode prend deux paramètres. Dans la méthode principale, nous appelons les deux méthodes l'une après l'autre et le compilateur résout l'appel de fonction en fonction du nombre de paramètres spécifié.
# 3) Séquence de paramètres
La troisième approche de la mise en œuvre de la surcharge de méthode est basée sur la séquence de paramètres dans les méthodes surchargées.
Prenons l'exemple suivant de la déclaration de méthode,
somme (int, flottant);
somme (float, int);
Ici, nous avons une somme de méthodes surchargée. Dans la première déclaration, les paramètres sont int et float. Dans la deuxième déclaration également, les paramètres sont int et float mais leur ordre dans la liste des paramètres est modifié.
Maintenant, le paramètre float apparaît en premier tandis que le paramètre int est le second. Nous pouvons réaliser une surcharge de méthode, en modifiant l'ordre des paramètres.
La ci-dessous le programme Java le démontre.
class MethodOverload { //overloaded method - char,int parameter public void printParam(char ch, int num) { System.out.println('Input character:' + ch + ' ; ' + 'Input Number:' + num); } //overloaded method - int,char parameter public void printParam(int num, char ch) { System.out.println('Input Number:' + num + ' ; ' + 'Input Character:' + ch); } } class Main { public static void main(String args[]) { MethodOverload obj = new MethodOverload(); obj.printParam('A', 100); //call overloaded method (char,int) obj.printParam(100, 'A'); //call overloaded method (int,char) } }
Production:
Dans le programme ci-dessus, nous avons une méthode surchargée printParam qui a des paramètres int et char dont l'ordre est changé dans deux déclarations de méthode.
Cas non valides de surcharge de méthode
Jusqu'à présent, nous avons discuté de la surcharge de méthode à l'aide de la liste de paramètres. Nous n'avons pas encore considéré le type de méthode de retour. Notez que nous ne surchargons pas les méthodes basées sur les types de retour.
Par exemple, si deux méthodes ont le même nom et les mêmes listes de paramètres mais des types de retour différents, alors nous ne disons pas que ces deux méthodes sont surchargées. Ce cas devient invalide pour surcharge.
test boîte blanche vs boîte noire
Donc, si nous avons les déclarations suivantes:
I int (int, int);
Somme de chaîne (int, int);
Dans ce cas, le compilateur émettra une erreur car deux méthodes ne sont pas surchargées. Par conséquent, uniquement basées sur les types de retour, les méthodes ne sont pas différenciées.
Voyons ce cas non valide à l’aide d’un programme Java.
class OverloadDemo { public double myMethod(int num1, int num2) { System.out.println('OverloadDemo::myMethod returns double'); return num1+num2; } public int myMethod(int var1, int var2) { System.out.println('OverloadDemo::myMethod returns int'); return var1-var2; } } class Main { public static void main(String args[]) { OverloadDemo obj2= new OverloadDemo(); obj2.myMethod(10,10); obj2.myMethod(20,12); } }
Dans le programme ci-dessus, la méthode myMethod a deux prototypes. Un prototype prend deux paramètres int et renvoie double. Le deuxième prototype de méthode prend deux paramètres int et renvoie un int.
Ainsi, lorsque nous compilons ce programme, nous obtenons la sortie ci-dessous.
Production:
L'erreur de compilation ci-dessus indique que la méthode est déclarée deux fois. Cela signifie que le compilateur ne considère pas ces méthodes surchargées simplement en fonction du type de retour.
Surcharge de l'opérateur
La surcharge d'opérateur est un mécanisme de surcharge dans lequel une signification différente est donnée à un opérateur existant.
Comme nous l'avons vu dans la section d'introduction de ce tutoriel, un opérateur d'addition «+» est un exemple classique de surcharge d'opérateurs.
Lorsque les opérandes de cet opérateur sont numériques, l'opérateur + renvoie le total de deux valeurs. Mais lorsque les opérandes sont de type String, le résultat de l'opération d'addition est la chaîne concaténée. Notez qu'en Java, nous ne pouvons surcharger que l'opérateur + (addition).
Cet opérateur remplit deux fonctions:
- Ajout d'entiers ou de valeurs numériques.
- Concaténation de chaînes
Par conséquent, la prise en charge de la surcharge d'opérateurs est limitée en Java contrairement à C ++ où nous pouvons surcharger presque tous les opérateurs à l'exception de quelques-uns comme sizeof, opérateur point, etc.
Le programme ci-dessous illustre la surcharge des opérateurs en Java.
class OperatorOverload { //overloaded method for concatenating two strings void operator(String str1, String str2) { String resultStr = str1 + str2; System.out.println('Concatenated String: ' + resultStr); } //overloaded method for adding two numbers void operator(int num1, int num2) { int result = num1 + num2; System.out.println('Sum of two numbers : ' + result); } } class Main { public static void main(String[] args) { OperatorOverload obj = new OperatorOverload(); obj.operator(10, 15); //add two numbers obj.operator('Hello ', 'World!!'); //concatenate two strings } }
Production:
Dans le programme ci-dessus, nous avons surchargé l’opérateur «+». Lorsque nous transmettons deux valeurs entières à la méthode surchargée, une somme de deux entiers est renvoyée et lorsque deux chaînes sont passées, le résultat est la chaîne concaténée.
Certains points à noter concernant la surcharge et le polymorphisme à la compilation.
- La surcharge de méthode est le moyen d'implémenter le polymorphisme à la compilation, également connu sous le nom de polymorphisme statique.
- Le polymorphisme statique est également appelé liaison précoce ou liaison à la compilation.
- Comme la liaison des paramètres et de l'appel de fonction se produit au moment de la compilation, la surcharge est appelée liaison au moment de la compilation.
- On ne peut surcharger que l’opérateur ‘+’ en Java et il effectue l’addition de deux entiers ou la concaténation de deux chaînes.
Questions fréquemment posées
Q # 1) Pourquoi avons-nous besoin du polymorphisme en Java?
Répondre: Le polymorphisme nous permet d'avoir de nombreuses implémentations pour un objet. Grâce à la surcharge de méthodes, nous n'avons pas besoin d'avoir trop de méthodes avec des noms différents qui sont difficiles à retenir. Nous pouvons à la place avoir des méthodes surchargées afin que nous puissions avoir une implémentation claire des méthodes exécutant des fonctions similaires.
La substitution aide également à la bonne implémentation de l'héritage qui nous permet d'ajouter plus de fonctionnalités aux classes existantes d'une manière plus simple.
Q # 2) Qu'est-ce que la POO du polymorphisme?
Répondre: La définition de programmation orientée objet du polymorphisme fait référence à la capacité des langages de programmation à implémenter un objet sous diverses formes. Le polymorphisme est également défini comme la capacité d'un programme à remplacer les méthodes de la classe parente dans la classe dérivée pour avoir des fonctionnalités supplémentaires.
Q # 3) Pouvons-nous surcharger et remplacer la méthode principale?
Répondre: Non, nous ne pouvons pas remplacer la méthode principale statique. Bien que nous puissions surcharger la méthode principale, JVM n'appellera jamais la méthode principale surchargée. La meilleure réponse est donc de ne pas surcharger ou remplacer la méthode principale.
Q # 4) Les constructeurs peuvent-ils être surchargés?
Répondre: Oui, nous pouvons surcharger les constructeurs en Java de la même manière que nous surchargons les méthodes Java. Les constructeurs ont généralement le même nom mais un nombre d'arguments différent.
Q # 5) Pourquoi la surcharge de méthode est-elle utile?
Répondre: Nous pouvons écrire du code propre en utilisant la surcharge de méthode et il devient également lisible car nous avons des méthodes avec le même nom. Donc, si nous implémentons des fonctionnalités pour différents types de données, nous pouvons surcharger les méthodes et il sera plus facile de séparer le code.
Conclusion
Le polymorphisme en Java signifie qu'un objet peut avoir plusieurs formes. Le polymorphisme en Java a deux types, à savoir le polymorphisme au moment de la compilation et le polymorphisme à l'exécution. Le polymorphisme à la compilation est effectué au moment de la compilation. Le polymorphisme à la compilation est statique et est implémenté via une surcharge de méthode et une surcharge d'opérateur.
Le polymorphisme d'exécution est effectué à l'exécution et est dynamique. Il est implémenté en utilisant la substitution de méthode.
Dans ce tutoriel, nous avons vu les moyens d'implémenter la surcharge de méthode. Nous avons également discuté en détail de la surcharge des opérateurs. Java ne prend en charge que la surcharge de l’opérateur «+».
=> Lisez la série de formations Easy Java.
lecture recommandée
- Tutoriel sur la méthode Java String contains () avec des exemples
- Méthode Java String length () avec exemples
- Méthode Java substring () - Tutoriel avec des exemples
- Tutoriel Java Float avec des exemples de programmation
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- TreeMap en Java - Tutoriel avec des exemples de TreeMap Java
- Tutoriel Java String | Méthodes de chaîne Java avec exemples
- Java Double - Tutoriel avec des exemples de programmation