Table des matières
Lorsque vous travaillez avec Java la génération de programme peut bientôt nous mettre dans la situation où nous devons écrire de nombreuses lignes de code pour atteindre nos objectifs et bien que ce ne soit pas mal, c'est le cas si la plupart de ce code est redondant.Pour éviter cela, nous devons faire programmes modulaires, avec laquelle nous éviterons d'avoir à réécrire les mêmes routines encore et encore, entre ici aussi le surcharge de méthodeCela consiste à créer des méthodes du même nom mais qui reçoivent des paramètres différents, afin que nous puissions effectuer des opérations dans divers scénarios sans avoir à créer des noms différents pour les méthodes.
Modularisation d'un programme
Ce concept comme nous l'évoquions au début du tutoriel correspond à créer routines réutilisables Au sein de notre programme, nous pouvons ainsi remplir l'une des prémisses de la programmation orientée objet, qui est la réutilisabilité du code.
Comment est-il atteint ?Nous atteignons cette modularité par la construction de méthodes aussi génériques que possible afin que nous puissions les utiliser dans différentes instances de notre programme et même les utiliser dans d'autres programmes, réduisant ainsi le nombre de lignes de code que nous devons écrire.
En réalisant cela, nous pouvons réduire temps de développement, améliorer la productivité et la maintenance cela devient plus simple, par exemple si nous trouvons une erreur dans notre programme et qu'elle se trouve à l'intérieur d'une méthode en la corrigeant, cette correction s'appliquera à toutes les parties où la méthode est appelée.
Surcharge de méthode
La surcharge de méthode permet de créer plusieurs méthodes avec le même nom mais qui peuvent recevoir des paramètres différents, donc si on a plusieurs cas, Java il décidera en fonction des paramètres reçus par les méthodes lesquels invoquer.
C'est vraiment utile quand, par exemple, nous avons une méthode qui attend valeurs entières, mais ils peuvent aussi être valeurs doubles ou même par le nombre de paramètres.
Dans l'exemple suivant, nous allons créer un programme où nous calculerons la valeur la plus élevée entre des nombres donnés, ceux-ci peuvent être entiers ou doubles et nous allons même changer le nombre de paramètres reçus. Voyons le code :
public class Overload {/ ** Main Method * / public static void main (String [] args) {// Nous invoquons la méthode max avec les paramètres int System.out.println ("Le maximum entre 3 et 4 est :" + max ( 3. 4)); // On invoque la méthode max avec les paramètres double System.out.println ("Le maximum entre 3.0 et 5.4 est :" + max (3.0, 5.4)); // On invoque la méthode max avec 3 paramètres int System.out.println ("Le maximum entre 3.0, 5.4 et 10.14 est :" + max (3.0, 5.4, 10.14)); } public statique int max (int num1, int num2) {if (num1> num2) renvoie num1; sinon retourne num2; } public statique double max (double num1, double num2) {if (num1> num2) return num1; sinon retourne num2; } public statique double max (double num1, double num2, double num3) {return max (max (num1, num2), num3); } Nous voyons que dans la section dans laquelle nous définissons les méthodes à la fois celle qui reçoit valeurs entières comme celui qui reçoit valeurs doubles ils sont identiques sauf pour la définition des paramètres qu'ils reçoivent et la meilleure partie est dans la méthode qui reçoit les 3 paramètres, puisqu'ici nous réutilisons notre code et nous appelons le méthode max mais nous regroupons au sein d'un autre appel pour maxer les deux premières valeurs et la troisième séparément, avec cela nous réutilisons notre propre code.
Pour finir le tutoriel, voyons le résultat que le code précédent devrait nous donner via la console :
AGRANDIR
