Paramètres de méthode en Java

Les paramètres sont les entrées qu'une méthode déclare ; les arguments sont les valeurs que vous fournissez lors de l'appel. Le compilateur vérifie que les arguments correspondent aux paramètres par type et par position, puis les transmet à la méthode comme des variables locales utilisables dans son corps.

Ce chapitre détaille ce transfert — la syntaxe, les types que vous pouvez passer et les règles que Java applique pour convertir entre eux.

Déclarer des paramètres

La liste de paramètres d'une méthode est une suite de paires Type nom séparées par des virgules :

public static void greet(String name, int times) {
  for (int i = 0; i < times; i++) {
    System.out.println("Hello, " + name);
  }
}

Une méthode peut déclarer zéro, un ou plusieurs paramètres. Chacun doit avoir son propre type — il n'existe pas de raccourci comme int a, b (cela représente int a suivi de b, ce qui ne compilera pas).

Appeler avec des arguments

Au site d'appel, vous passez les valeurs dans le même ordre que celui dans lequel les paramètres sont déclarés :

greet("Ada", 3);    // name = "Ada", times = 3

Le compilateur vérifie deux choses :

1. Arité — le nombre d'arguments correspond au nombre de paramètres.
2. Types — le type de chaque argument est compatible avec le type du paramètre correspondant.

Si l'une de ces vérifications échoue, votre programme ne compilera pas. Passer un String là où un int est attendu produira une erreur du type incompatible types: String cannot be converted to int.

Les paramètres sont des variables locales

À l'intérieur de la méthode, chaque paramètre se comporte comme une variable locale initialisée à la valeur de l'argument :

public static int doubleIt(int n) {
  n = n * 2;          // legal: n is just a local
  return n;
}

int x = 5;
int result = doubleIt(x);   // result is 10
System.out.println(x);       // still 5

Réaffecter n à l'intérieur de doubleIt n'affecte pas x au site d'appel. Chaque appel obtient sa propre copie fraîche du paramètre. C'est ce que les gens veulent dire quand ils disent que Java est « pass-by-value » — chaque argument est copié dans l'emplacement du paramètre. Les chapitres suivants couvrent les implications, notamment pour les arguments objets.

Élargissement implicite

Java élargit automatiquement un type numérique plus petit vers un type plus grand pour correspondre au paramètre :

public static double half(double x) {
  return x / 2;
}

int n = 7;
double result = half(n);   // n is widened from int to double

L'élargissement est autorisé car aucune information n'est perdue. Le rétrécissement n'est pas implicite — passer un double à un paramètre int nécessite un cast :

half(7.5);            // fine: double argument, double parameter
double d = 3.7;
int i = (int) d;      // explicit cast
half(i);              // also fine

Les mêmes règles d'élargissement s'appliquent qu'avec l'affectation : byte → short → int → long → float → double, et char → int.

Paramètres objets

Vous pouvez passer n'importe quel objet — String, un tableau, une classe personnalisée — en déclarant un paramètre du type référence correspondant :

public static int firstLength(String[] words) {
  if (words.length == 0) return 0;
  return words[0].length();
}

String[] colors = {"red", "green", "blue"};
System.out.println(firstLength(colors));   // 3

L'argument peut également être null, auquel cas le paramètre est null et tout accès à un champ ou appel de méthode sur celui-ci lève une NullPointerException. Les méthodes qui acceptent des références vérifient généralement d'abord ou documentent que null n'est pas autorisé.

Passer null

null est compatible en affectation avec tout type référence, vous pouvez donc le passer pour n'importe quel paramètre objet :

greet(null, 1);

Si la méthode déréférence le paramètre (name.length(), name.charAt(0), …), elle lève une exception. Une méthode défensive gère null explicitement, souvent avec une garde au début :

public static void greet(String name, int times) {
  if (name == null) name = "stranger";
  for (int i = 0; i < times; i++) {
    System.out.println("Hello, " + name);
  }
}

Paramètres finaux

Vous pouvez marquer un paramètre final pour interdire sa réaffectation à l'intérieur de la méthode :

public static int doubleIt(final int n) {
  // n = n * 2;     // ERROR: cannot assign a value to final variable n
  return n * 2;
}

Cela ne change pas ce que voit l'appelant — seulement si le corps est autorisé à réutiliser l'emplacement du paramètre. De nombreux guides de style traitent tous les paramètres comme s'ils étaient final même sans le mot-clé ; calculez simplement de nouvelles valeurs plutôt que de muter le paramètre.

Ordre d'évaluation des arguments

Lorsque vous écrivez f(a(), b(), c()), les arguments sont évalués de gauche à droite, tous avant que f soit appelée. Si a() lève une exception, b() et c() ne s'exécutent jamais.

public static int log(String label, int value) {
  System.out.println(label + " = " + value);
  return value;
}

public static int sum(int a, int b, int c) {
  return a + b + c;
}

sum(log("a", 1), log("b", 2), log("c", 3));
// prints:
//   a = 1
//   b = 2
//   c = 3

Ce déterminisme diffère de C et C++ ; en Java l'ordre est fixe et prévisible.

Un exemple complet

Et ensuite

Vous savez maintenant comment les données entrent dans une méthode. Parfois vous souhaitez deux méthodes portant le même nom mais avec des entrées différentes — par exemple, une qui accepte un int et une autre qui accepte un String. Java vous permet d'écrire les deux en même temps grâce à la surcharge de méthode.

Pratique