Paramètres de fonction en Java

1. Passer des arguments

Et maintenant, le plaisir commence. Vous savez probablement déjà à partir de méthodes comme celle-ci System.out.println()que nous pouvons passer des arguments aux méthodes. Une fois que nous sommes à l'intérieur de la méthode, nous nous référons à eux en tant que paramètres. 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.

Comment déclarer une méthode avec des paramètres ? C'est en fait assez simple :

public static void name(parameters)
{
  method body
}

Où name est le nom unique de la méthode et method body représente les commandes qui composent la méthode. Et parameters est un espace réservé pour les paramètres de méthode, séparés par des virgules. Décrivons ce modèle plus en détail :

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

Exemples:

public static void print(String str)
{
}

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

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

Si nous ne voulons pas que la méthode ait des paramètres, nous laissons simplement les parenthèses vides.

Les paramètres sont des variables spéciales dans une méthode. Avec leur aide, vous pouvez transmettre diverses valeurs à la méthode lorsqu'elle est appelée.

Par exemple, écrivons une méthode qui affiche une chaîne de texte un certain nombre de fois.

Vous savez déjà comment écrire du code pour afficher plusieurs fois une chaîne à l'écran. Mais quelle chaîne devez-vous imprimer ? Et combien de fois ? C'est pour cela que nous avons besoin des paramètres.

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.

2. Arguments

Je voudrais attirer un peu plus votre attention sur l'appel d'une méthode avec des paramètres.

Les valeurs transmises à la méthode sont généralement appelées arguments lorsqu'elles sont transmises à la méthode.

Prenons un autre 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 printLines mé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 qui reçoivent certaines valeurs lorsqu'une méthode est appelée. Les valeurs "Hi", "Bye", 10et 20sont elles-mêmes appelées arguments."

3. Noms de variables conflictuels lors de l'appel d'une méthode

Les variables peuvent être utilisées comme arguments de méthode. C'est simple et compréhensible, mais cela peut potentiellement produire quelques difficultés. Revenons au même exemple, mais cette fois nous allons déplacer 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";
     int n = 10;
     printLines(str, n);
   }
}

Jusqu'ici, tout va bien : nous avons une strvariable. Sa valeur est affectée au textparamètre lors de l'appel de la méthode. Nous avons une nvariable. Sa valeur est affectée au countparamètre lors de l'appel de la méthode." Jusqu'ici, tout est clair.

Renommez maintenant 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";
     int count = 10;
     printLines(text, count);
   }
}

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é. Il s'agissait auparavant de variables différentes dans différentes méthodes , et elles le restent. Il n'y a pas de lien magique entre les variables text et text .

4. Passer des références aux méthodes

J'espère que vous avez tout compris de la leçon précédente, car maintenant nous allons revoir le passage d'arguments aux méthodes, seulement nous allons approfondir.

Comme vous le savez déjà, certaines variables 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.

Lorsque vous affectez une autre variable tableau à une variable tableau, que se passe-t-il ? C'est exact. 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 printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

Il se passe exactement la même chose : le data paramè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 comme les deux variables font référence à la même zone de mémoire stockant un entier, la printArraySum méthode peut non seulement lire les valeurs du tableau, mais aussi les modifier !

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);
   }
}

5. Méthodes du même nom

Revenons maintenant aux noms de méthodes une fois de plus.

Les normes Java exigent que toutes les méthodes d'une même classe aient des noms uniques. En d'autres termes, il est impossible de déclarer deux méthodes portant le même nom dans la même classe.

Lorsque les méthodes sont comparées pour la similarité, non seulement les noms sont pris en compte, mais aussi les types des paramètres ! Notez que 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) {
}

Pourquoi certaines méthodes sont-elles considérées comme identiques alors 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 ? 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.System.out.println("Hi")println()String

Mais si vous écrivez , le compilateur verra un appel à la méthode avec un paramètre.System.out.println(1.0)println()double

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 la méthode à appeler. Et c'est pourquoi ils ne sont pas pris en compte lors de la détermination de l'unicité d'une méthode.

Le nom d'une méthode et les types de ses paramètres sont appelés signature de méthode . Par exemple,sum(int, int)

Chaque classe doit avoir des méthodes avec des signatures uniques plutôt que des méthodes avec des noms uniques.