Les méthodes en Java

Une méthode en Java est un bloc de code nommé que vous pouvez appeler depuis n'importe où dans le programme. Les méthodes permettent d'éviter la répétition : au lieu d'écrire le même calcul ou la même opération de cinq lignes à trois endroits différents, vous la placez dans une méthode et vous l'appelez trois fois.

Vous avez déjà vu une méthode sur chaque page de ce livre — main. Tout programme Java est simplement une classe avec au moins une méthode que la JVM sait comment démarrer. Dans cette partie du livre, nous verrons comment écrire les vôtres.

Anatomie d'une méthode

Une déclaration de méthode comporte jusqu'à cinq parties : les modificateurs, un type de retour, un nom, une liste de paramètres et un corps.

public static int square(int n) {
  return n * n;
}

• public static — modificateurs. public contrôle la visibilité ; static signifie que la méthode appartient à la classe plutôt qu'à une instance. Nous approfondirons ces deux notions dans les parties suivantes ; pour l'instant, chaque méthode que vous écrivez dans une classe utilitaire de premier niveau sera public static.
• int — le type de retour. Le type de valeur que la méthode renvoie à son appelant. Utilisez void si elle ne renvoie rien.
• square — le nom. Par convention en lowerCamelCase, et un verbe ou une locution verbale qui indique ce que fait la méthode.
• (int n) — la liste de paramètres. Les entrées que l'appelant doit fournir. Chaque paramètre est un type et un nom.
• { ... } — le corps. Le code qui s'exécute lorsque la méthode est appelée.

Appeler une méthode

Une fois définie, vous appelez une méthode en écrivant son nom suivi de (...) avec les valeurs des arguments :

int result = square(7);   // result is 49
System.out.println(square(3) + square(4));   // 9 + 16 = 25

La valeur renvoyée par la méthode peut être utilisée comme n'importe quelle autre expression — affectée à une variable, passée comme argument, affichée, additionnée à autre chose.

L'instruction return

return fait deux choses : elle arrête immédiatement la méthode et renvoie une valeur à l'appelant.

public static int absolute(int n) {
  if (n < 0) {
    return -n;
  }
  return n;
}

Une fois que return -n s'exécute, la méthode est terminée — le second return n ne s'exécute pas. Une méthode avec un type de retour non void doit retourner une valeur sur tous les chemins de code possibles ; le compilateur refuse de compiler si un chemin est manquant.

Pour les méthodes void, vous pouvez utiliser un return; seul pour quitter prématurément, mais vous n'êtes pas obligé d'en écrire un à la fin :

public static void greet(String name) {
  if (name == null) return;          // early exit
  System.out.println("Hello, " + name);
}                                    // implicit return at the closing brace

Paramètres et arguments

Les noms dans la signature de la méthode sont des paramètres ; les valeurs que vous passez au site d'appel sont des arguments. La distinction est subtile mais vaut la peine d'être maîtrisée :

public static int sum(int a, int b) {   // a, b are parameters
  return a + b;
}

int x = 3, y = 4;
int total = sum(x, y);                   // x, y are arguments

Chaque appel obtient ses propres copies fraîches des paramètres. Affecter une valeur à a à l'intérieur de sum ne change pas x au site d'appel. Le chapitre sur le passage par valeur en détaille les subtilités.

Règles sur les types de retour

L'expression après return doit être compatible à l'affectation avec le type de retour déclaré — même type, ou un type que Java peut élargir vers lui :

public static double half(int n) {
  return n / 2.0;       // int / double → double, fine
}

public static int half(int n) {
  return n / 2.0;       // ERROR: double cannot be implicitly narrowed to int
}

Si vous avez vraiment besoin de réduire, vous effectuez un cast explicite : return (int)(n / 2.0);.

Les méthodes peuvent appeler d'autres méthodes

Le corps d'une méthode est du code ordinaire — y compris des appels à d'autres méthodes, voire à elle-même (voir la récursivité) :

public static int square(int n)   { return n * n; }
public static int sumOfSquares(int a, int b) {
  return square(a) + square(b);
}

Construire de petites méthodes à but unique et les composer est au cœur de l'écriture d'un code Java lisible.

Retourner n'est pas afficher

Une confusion courante chez les débutants : une méthode qui affiche une valeur et une méthode qui retourne une valeur ne sont pas interchangeables. return renvoie une valeur à l'appelant pour qu'il puisse l'utiliser ; System.out.println écrit simplement du texte dans la console et l'appelant ne reçoit rien.

public static void printSquare(int n) {
  System.out.println(n * n);   // shows the result, returns void
}

public static int square(int n) {
  return n * n;                // gives the result back to the caller
}

Vous pouvez stocker, additionner ou transmettre le résultat de square, mais int x = printSquare(5); ne compilera pas — printSquare retourne void. Préférez retourner une valeur et laisser l'appelant décider de l'afficher ou non ; cela rend la méthode réutilisable.

La surcharge : même nom, paramètres différents

Java permet à deux méthodes ou plus de partager un nom tant que leurs listes de paramètres diffèrent — en nombre de paramètres ou en types. C'est ce qu'on appelle la surcharge, et le compilateur choisit la bonne en fonction des arguments passés :

public static int max(int a, int b)          { return a > b ? a : b; }
public static double max(double a, double b)  { return a > b ? a : b; }
public static int max(int a, int b, int c)    { return max(max(a, b), c); }

max(3, 9) appelle la première, max(2.5, 1.5) la deuxième, et max(4, 1, 7) la troisième. Le type de retour seul ne suffit pas à distinguer les surcharges — seuls les paramètres comptent. Le chapitre sur la surcharge de méthodes couvre les règles de correspondance en détail.

Où vivent les méthodes

Une méthode vit toujours à l'intérieur d'une classe. Vous ne pouvez pas écrire une fonction de premier niveau comme vous pouvez le faire en JavaScript ou Python. La classe est le conteneur ; la méthode est l'un de ses membres. Ainsi, un fichier complet avec deux méthodes ressemble à ceci :

public class MathUtils {
  public static int square(int n) {
    return n * n;
  }

  public static int cube(int n) {
    return n * n * n;
  }
}

Depuis main dans la même classe, vous les appelleriez avec square(5) et cube(2). Depuis une classe différente, vous les qualifieriez : MathUtils.square(5).

Un exemple complet

La suite

Maintenant que vous savez déclarer et appeler une méthode, la question suivante est de savoir comment les données y circulent. Le chapitre sur les paramètres en détaille les mécanismes — comment les arguments correspondent aux paramètres, quels types sont autorisés, et ce qui se passe lorsque l'appelant passe des objets plutôt que des primitives.

Pratique