Paramètres de méthode en Java

"Salut Amigo ! J'espère que vous avez aimé résoudre des tâches en utilisant vos propres méthodes et que vous réalisez à quel point il est pratique de créer des méthodes. Parlons maintenant du sujet le plus intéressant de tous."

"Tu as piqué ma curiosité, Diego... Un nouveau sujet ?"

"Chaque sujet est nouveau pour vous, mon jeune robot ! Et celui-ci ne fait pas exception. Bien qu'il s'agisse encore une fois de méthodes. Vous avez probablement déjà remarqué qu'avec des méthodes comme celle-ci, nous pouvons passer des arguments aux méthodes. Une fois que nous sommes à l'intérieur de la System.out.println()méthode , nous nous y référons en tant que paramètres."

"Les paramètres sont ce que nous écrivons entre parenthèses ?"

"Oui, exactement. Et, en fait, les paramètres améliorent considérablement les avantages que nous tirons de la création et de l'utilisation de méthodes."

"Je comprends ce que vous dites sur leur utilisation, et il s'avère que je l'ai déjà fait. Comment déclarer une méthode avec des paramètres?"

« En fait, c'est assez simple :

public static void name(parameters)
{
  method body
}

"Où nameest le nom unique de la méthode et method bodyreprésente les commandes qui composent la méthode. Et parametersest un espace réservé pour les paramètres de la méthode, séparés par des virgules."

"Hmm... Je pense que je comprends... Ou peut-être pas..."

"Laissez-moi vous donner plus de détails sur ce modèle afin que vous soyez certain que vous comprenez que vous comprenez :

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

Voici quelques exemples:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

"Ah... Maintenant c'est clair. Et si nous ne voulons pas que la méthode ait des paramètres, alors nous laissons simplement les parenthèses vides."

"Exactement. Fondamentalement, les paramètres sont des variables spéciales au sein d'une méthode. Avec leur aide, vous pouvez transmettre diverses valeurs à la méthode lorsqu'elle est appelée. Et si vous n'avez pas besoin de transmettre des valeurs, vous laissez les parenthèses vides.

"Par exemple, écrivons une méthode qui affiche une ligne de texte donnée un certain nombre de fois. Des idées sur la façon de faire cela?"

"Eh bien... Il semble que je sois bien conscient de la façon d'écrire du code pour afficher une chaîne à l'écran plusieurs fois..."

« Comment spécifiez-vous la chaîne à afficher ? Et comment spécifiez-vous le nombre de lignes affichées ? Pouvez-vous deviner ? »

"Les choses commencent à devenir claires... Probablement à l'aide de paramètres de méthode ?"

"Exactement. Un paramètre de chaîne pour la ligne de texte et un paramètre numérique pour le nombre de lignes affichées. Le code qui fait cela ressemblerait à ceci :

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

"Chaque fois qu'une méthode est appelée, ses paramètres reçoivent les valeurs transmises, et ce n'est qu'alors que nous commençons à exécuter les commandes à l'intérieur de la méthode.

Arguments

"Je veux que vous prêtiez une attention particulière aux méthodes d'appel qui ont des paramètres. Les valeurs transmises à la méthode sont généralement appelées arguments lorsqu'elles sont transmises à la méthode.

Reprenons notre exemple :

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

"Lorsque la printLinesméthode a été appelée pour la première fois, ses paramètres ont reçu les valeurs suivantes :

String text = "Hi", int count = 10.

"Lorsque la printLinesméthode a été appelée la deuxième fois, ses paramètres ont reçu des valeurs différentes :

String text = "Bye", int count = 20.

"Les paramètres ne sont ni plus ni moins que des variables auxquelles sont assignées certaines valeurs lorsqu'une méthode est appelée. Les valeurs "Hi", "Bye", 10et 20sont elles-mêmes appelées arguments."

"Je vais essayer de me souvenir de la différence et de ne pas confondre ces concepts."

Noms de variable en conflit lors de l'appel d'une méthode

"Lorsque vous appelez une méthode, vous pouvez utiliser des variables comme arguments.

"Eh bien, c'est logique !"

"Cela a du sens, mais cela peut potentiellement produire des difficultés. Revenons à notre exemple une fois de plus, mais cette fois nous déplacerons les arguments dans des variables distinctes :

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... Je ne vois aucune difficulté. Nous avons une strvariable. Sa valeur est assignée au textparamètre lorsque la méthode est appelée. Nous avons une nvariable. Sa valeur est assignée au countparamètre lorsque la méthode est appelée." "Jusqu'à présent, tout est clair."

"Bien, bien. Maintenant, renommons nos variables dans la mainméthode :

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     String count = 10;
     printLines(text, count);
   }
}

« Faites attention à deux choses

Premièrement : nous avons des variables portant le même nom dans différentes méthodes. Ce sont des variables différentes (nous les représentons délibérément en utilisant des couleurs différentes). Tout fonctionne de la même manière que dans l'exemple précédent, où les variables de la mainméthode étaient nommées stret n.

Deuxièmement : rien de magique ne se produit lorsque la méthode est appelée. Les paramètres reçoivent simplement les valeurs d'argument. Qu'il s'agisse de nombres, de chaînes, de variables ou d'expressions.

"Après avoir renommé les variables dans la méthode principale, rien n'a changé. C'étaient des variables différentes dans différentes méthodes auparavant, et elles restent donc. Il n'y a pas de lien magique entre les deux textvariables."

"Maintenant je sais."

Passer des références à des méthodes

"J'espère que vous avez déjà assimilé tout ce que je vous ai dit sur le passage des arguments aux méthodes. Je dis cela, car nous allons maintenant approfondir un peu ce sujet. Écoutez attentivement."

"Vous savez déjà que certaines variables en Java ne stockent pas les valeurs elles-mêmes, mais plutôt une référence , c'est-à-dire l'adresse du bloc de mémoire où se trouvent les valeurs. C'est ainsi que fonctionnent les variables de chaîne et les variables de tableau.

"Lorsqu'un développeur affecte une autre variable de tableau à une variable de tableau, que se passe-t-il ?"

"Est-ce qu'ils pointent alors vers la même adresse ?"

"Correct. Les deux variables commencent à se référer au même espace en mémoire :

"Et que se passe-t-il si l'une de ces variables est un paramètre de méthode ?

class Solution
{
   public static void sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

"Exactement la même chose se produit : le dataparamètre contiendra une référence à la même zone de mémoire que la monthsvariable. Lorsque la méthode est appelée, une simple affectation se produit : .data = months

"Et puisque les deux variables font référence à la même zone de mémoire stockant un entier, la summéthode peut non seulement lire les valeurs du tableau, mais aussi les modifier !"

« Je suppose que je comprends, mais j'ai besoin de plus d'exemples !

"Eh bien, par exemple, nous pouvons écrire notre propre méthode qui remplit un tableau à deux dimensions avec la même valeur. Voici à quoi cela pourrait ressembler :

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

Méthodes du même nom

"Maintenant, revenons aux noms de méthodes une fois de plus."

"Je ne peux pas imaginer ce qu'on pourrait dire d'autre sur les noms !"

"Eh bien, la norme du langage Java exige que toutes les méthodes d'une même classe aient des noms uniques.

« Donc, il est impossible de déclarer deux méthodes portant le même nom dans la même classe ? »

"Maintenant, faites très attention ! Les méthodes d'une classe peuvent en effet avoir des noms identiques ! Mais dans ce cas, elles doivent avoir des paramètres différents. En d'autres termes, les méthodes sont comparées pour la similitude, non seulement les noms sont pris en compte, mais aussi les types des paramètres ! Notez que j'ai spécifiquement dit types. Les noms des paramètres ne sont pas pris en compte . Exemples :

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

"Je suis totalement confus ! Pourquoi avons-nous besoin de tout cela ? Pourquoi certaines méthodes sont-elles considérées comme identiques , tandis que d'autres sont différentes ? Et pourquoi les noms de paramètres ne sont-ils pas pris en compte lors de la détermination de l'unicité d'une méthode ? Pourquoi l'unicité est-elle nécessaire à tous?"

"Le fait est que lorsque le compilateur compile un programme, il doit savoir exactement quelle méthode vous avez l'intention d'appeler à un endroit donné.

"Par exemple, si vous écrivez , le compilateur est intelligent et conclura facilement que vous avez l'intention d'appeler la méthode ici avec un paramètre. Mais si vous écrivez , le compilateur verra un appel à la méthode avec un paramètre. Il n'a aucune idée quel nom le programmeur a donné au paramètre lors de la déclaration de la méthode."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, ça semble commencer à passer !

"Lorsqu'une méthode est appelée, le compilateur s'assure que les types des arguments correspondent aux types des paramètres. Il ne prête aucune attention au nom des arguments. En Java, les noms de paramètres n'aident pas le compilateur à déterminer quelle méthode utiliser. Les programmeurs en ont besoin, pas le compilateur.

"Et je suppose que c'est pourquoi ils ne sont pas pris en compte lors de la détermination de l'unicité d'une méthode?"

"Oui, c'est tout à fait correct. Le nom d'une méthode et les types de ses paramètres s'appellent la signature de la méthode . Par exemple, sum (int, int)"

"Ainsi, chaque classe doit avoir des méthodes avec des signatures uniques plutôt que des méthodes avec des noms uniques."

"Bien joué, Amigo ! Vous avez parfaitement résumé cette leçon. Si quelque chose reste flou, ne paniquez pas. Ce sujet deviendra clair après quelques tâches."