Paramètres de méthode en Java : arguments, passage par valeur et retour

Les paramètres permettent à une méthode de recevoir des entrées

Une méthode qui fait toujours la même chose est limitée. Les paramètres sont les entrées que tu déclares entre les parenthèses de la méthode pour que la même méthode puisse travailler sur des valeurs différentes à chaque appel.

Tu listes chaque paramètre avec un type et un nom. À l'intérieur du corps de la méthode, un paramètre se comporte comme une variable locale ordinaire qui contient déjà ce que l'appelant a passé.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name est le paramètre. "Sam" et "Alex" sont les arguments - les valeurs concrètes fournies lors de l'appel. Une seule définition de méthode, deux sorties différentes.

Paramètres versus arguments

Ces deux mots sont employés de façon approximative, mais la distinction mérite d'être gardée claire :

• Un paramètre est l'espace réservé dans la déclaration : String name.
• Un argument est la valeur que tu passes réellement : "Sam".

Ainsi void greet(String name) déclare un paramètre, et greet("Sam") passe un argument. Quand quelqu'un dit « cette méthode prend deux paramètres », il parle de la déclaration ; « j'ai passé deux arguments » parle de l'appel.

Paramètres multiples

Sépare les paramètres par des virgules et donne à chacun son propre type - tu ne peux pas partager un type entre deux paramètres comme tu pourrais le faire dans une déclaration de variable :

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Les arguments sont associés aux paramètres strictement par position, pas par nom. describe("Sam", 30, true) fonctionne parce que l'ordre correspond à (String name, int age, boolean active). Inverse deux arguments de types compatibles et tu obtiens un bug de logique silencieux, pas une erreur de compilation - donc l'ordre compte.

Une erreur courante consiste à écrire int add(int a, b). Chaque paramètre a besoin de son propre type : int add(int a, int b).

Retourner une valeur

Les paramètres sont la manière dont les données entrent ; la valeur de retour est la manière dont un résultat ressort. Déclare le type de retour avant le nom de la méthode, et utilise return pour renvoyer une valeur à l'appelant :

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 force la division en virgule flottante
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

Le type de retour (double) doit correspondre à ce que tu fais réellement avec return. Une méthode déclarée void ne retourne rien - elle peut tout de même utiliser un simple return; pour sortir plus tôt, mais elle ne peut pas retourner de valeur. Au moment où return s'exécute, la méthode se termine et le contrôle revient au site de l'appel.

Java fonctionne par passage par valeur

Cela déroute presque tout le monde au début. Quand tu passes un argument, Java copie la valeur dans le paramètre. Pour les primitifs, cela signifie que la méthode obtient sa propre copie - modifier le paramètre ne touche jamais la variable de l'appelant :

public class Main {
    static void tryToChange(int n) {
        n = 999;   // modifie seulement cette copie locale
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // toujours 5
    }
}

x reste à 5. La méthode a modifié sa propre copie du nombre, pas l'original.

Passer des objets : toujours par valeur, mais attention à la référence

Les objets semblent être une exception, mais ils n'en sont pas une. Ce qui est copié, c'est la référence (la flèche pointant vers l'objet), pas l'objet lui-même. Donc la méthode pointe vers le même objet et peut le muter :

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // mute l'objet partagé - visible par l'appelant
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // réaffecte seulement la copie locale - NON visible
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // toujours [a, b, new] - la réaffectation ne s'est pas échappée
    }
}

Deux résultats différents, une seule règle. addItem suit la référence et modifie la liste réelle, donc l'appelant voit new apparaître. replace réaffecte le paramètre à une toute nouvelle liste - mais cela ne fait que repointer la copie locale de la référence, donc la list de l'appelant reste intacte. À retenir : tu peux modifier un objet via un paramètre, mais tu ne peux jamais faire pointer la variable de l'appelant vers un nouvel endroit.

Suite : la surcharge de méthodes

Tu sais maintenant comment fournir à une méthode exactement les entrées dont elle a besoin. Mais que faire si tu veux qu'un même nom de méthode accepte différents ensembles de paramètres - par exemple print(int) et print(String) ? C'est la surcharge de méthodes, et c'est la page suivante.