6. Méthodes

Déclaration de méthodes

La syntaxe de base d’une méthode :

typeRetour nomMethode(typeParam1 param1, typeParam2 param2) {
    // Corps de la méthode
    return valeur; // si nécessaire
}

Exemples simples :

public class ExemplesMethodes {
    // Méthode sans paramètre et sans retour
    public static void afficherBonjour() {
        System.out.println("Bonjour!");
    }

    // Méthode avec paramètres et retour
    public static int additionner(int a, int b) {
        return a + b;
    }

    // Méthode avec plusieurs paramètres
    public static double calculerMoyenne(double... notes) {
        double somme = 0;
        for (double note : notes) {
            somme += note;
        }
        return somme / notes.length;
    }
}

Passage de paramètres

En Java, les paramètres sont toujours passés par valeur. Cependant, pour les objets, c’est la référence qui est passée par valeur.

Exemple avec types primitifs :

public class ExempleSwap {
    // Cette méthode ne fonctionne PAS
    public static void swapQuiNeMarchePas(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        int x = 5;
        int y = 10;

        swapQuiNeMarchePas(x, y);

        // x est toujours 5, y est toujours 10
        System.out.printf("x=%d, y=%d%n", x, y);
    }
}

Solution avec une classe wrapper :

public class ExempleSwapFonctionnel {
    // Classe pour contenir une valeur modifiable
    static class Nombre {
        int valeur;

        Nombre(int valeur) {
            this.valeur = valeur;
        }
    }

    public static void swap(Nombre a, Nombre b) {
        int temp = a.valeur;
        a.valeur = b.valeur;
        b.valeur = temp;
    }

    public static void main(String[] args) {
        Nombre x = new Nombre(5);
        Nombre y = new Nombre(10);

        System.out.printf("Avant: x=%d, y=%d%n", x.valeur, y.valeur);
        swap(x, y);
        System.out.printf("Après: x=%d, y=%d%n", x.valeur, y.valeur);
    }
}

Exemple pratique complet

public class ManipulationTableaux {
    // Méthode qui modifie un tableau (le tableau est modifié car c'est une référence)
    public static void doubleElements(int[] tableau) {
        for (int i = 0; i < tableau.length; i++) {
            tableau[i] *= 2;
        }
    }

    // Méthode qui retourne un nouveau tableau
    public static int[] creerTableauDouble(int[] original) {
        int[] resultat = new int[original.length];
        for (int i = 0; i < original.length; i++) {
            resultat[i] = original[i] * 2;
        }
        return resultat;
    }

    // Méthode avec plusieurs paramètres de types différents
    public static String formaterNote(String nomEtudiant, double note, boolean afficherMention) {
        String mention = "";
        if (afficherMention) {
            mention = note >= 60 ? " (Réussite)" : " (Échec)";
        }
        return String.format("%s a obtenu %.1f%s", nomEtudiant, note, mention);
    }

    public static void main(String[] args) {
        // Test avec tableau (passage par référence)
        int[] nombres = {1, 2, 3, 4, 5};
        System.out.println("Avant modification:");
        for (int n : nombres) System.out.print(n + " ");
        System.out.println();

        doubleElements(nombres);

        System.out.println("Après modification:");
        for (int n : nombres) System.out.print(n + " ");
        System.out.println();

        // Test avec création d'un nouveau tableau
        int[] original = {1, 2, 3};
        int[] double1 = creerTableauDouble(original);

        System.out.println("\nTableau original inchangé:");
        for (int n : original) System.out.print(n + " ");
        System.out.println();

        System.out.println("Nouveau tableau:");
        for (int n : double1) System.out.print(n + " ");
        System.out.println();

        // Test du formatage de note
        String resultat = formaterNote("Alice", 85.5, true);
        System.out.println("\n" + resultat);
    }
}

Points clés à retenir

1. Les types primitifs sont toujours passés par valeur
2. Les objets sont passés par référence (techniquement, la référence est passée par valeur)
3. Pour modifier des valeurs primitives, il faut :
   • Soit retourner la nouvelle valeur
   • Soit encapsuler la valeur dans un objet
   • Soit utiliser un tableau
4. Les tableaux et les objets peuvent être modifiés à l’intérieur des méthodes
5. Une méthode peut avoir :
   • Aucun paramètre
   • Un ou plusieurs paramètres
   • Un nombre variable de paramètres (varargs)
   • Un type de retour ou void

---

Utilisation de l’IA

Page rédigée en partie avec l’aide d’un assistant IA. L’IA a été utilisée pour générer des explications, des exemples et/ou des suggestions de structure. Toutes les informations ont été vérifiées, éditées et complétées par l’auteur.