Les paramètres variables, ou Varargs, en Java permettent à une méthode d'accepter un nombre dynamique d'arguments. Cette fonctionnalité améliore la flexibilité et la lisibilité du code dans plusieurs cas d'usage.

1. Syntaxe de base

Pour déclarer une méthode avec des paramètres variables, utilisez la syntaxe type... nomParamètre, en veillant à ce qu'il soit toujours le dernier paramètre :

public void afficherValeurs(String etiquette, double... valeurs) {
    System.out.print(etiquette + ": ");
    for (double val : valeurs) {
        System.out.print(val + " ");
    }
    System.out.println();
}

2. Appels possibles

• Passage de plusieurs valeurs :

afficherValeurs("Mesure", 1.5, 2.7, 3.1);
// Sortie : Mesure : 1.5 2.7 3.1

• Passage d'un tableau existant :

double[] mesures = {4.2, 5.8, 6.0};
afficherValeurs("Tableau", mesures);
// Sortie : Tableau : 4.2 5.8 6.0

• Appel sans arguments :

afficherValeurs("Vide");
// Sortie : Vide : (aucune valeur)

3. Contraintes importantes

(1) Position obligatoire

Le paramètre variable doit toujours être placé en dernière position :

// Erreur de compilation : les varargs doivent être en dernier
public void mauvaiseDéclaration(int... entiers, String texte) {}

(2) Priorité lors de la surcharge

Une méthode avec des paramètres fixes est préférée à une méthode avec varargs si les types correspondent :

public void traiter(int a, int b) {}
public void traiter(int... valeurs) {}

traiter(1, 2);   // Appelle la première méthode
traiter(1);      // Appelle la seconde

(3) Ambiguïté de surcharge

Deux méthodes avec des varargs de types différants peuvent entraîner une erreur de comiplation si l'appel est ambigu :

public void traiter(String... noms) {}
public void traiter(Integer... indices) {}

traiter(); // Compilation échouée : impossible de déterminer la méthode cible

(4) Gestion des valeurs null

Passer null comme argument peut provoquer une exception :

afficherValeurs(null, 10, 20); // Le paramètre 'etiquette' est null → risque d'NullPointerException

Il est recommandé de vérifier les valeurs entrantes :

public void afficherValeurs(String etiquette, double... valeurs) {
    String etiq = (etiquette == null) ? "Sans étiquette" : etiquette;
    // Traitement sécurisé
}

4. Implémentation interne

À la compilation, les paramètres variables sont transformés en tableaux :

// Code source
public static void calculerSomme(int... nombres) {}

// Équivalent compilé
public static void calculerSomme(int[] nombres) {}

5. Cas d'usage réels

(1) Système de journalisation

public class Journal {
    public static void enregistrer(String format, Object... objets) {
        String message = String.format(format, objets);
        System.out.println(message);
    }
}

// Utilisation
Journal.enregistrer("Utilisateur %s connecté (%d tentatives)", "Bob", 5);

(2) Calculs mathématiques

public static double maximum(double... valeurs) {
    if (valeurs.length == 0) {
        throw new IllegalArgumentException("Aucune valeur fournie");
    }
    double max = valeurs[0];
    for (double val : valeurs) {
        if (val > max) max = val;
    }
    return max;
}

// Appel
double resultat = maximum(2.3, 9.7, 4.1); // Renvoie 9.7

6. Conclution

• Avantages : simplification de l'appel, meilleure adaptabilité aux nombres variables d'arguments.
• Précautions : respecter l'ordre des paramètres, éviter les conflits de surcharge, gérer les cas null.
• Scénarios idéaux : outils utilitaires, log, opérations sur des collections de même type.

L'utilisation judicieuse des paramètres variables contribue à un code plus élégant, lisible et maintenable.