Définition et Invocation des Méthodes

Lors de la création d'une méthode, deux aspects clés doivent être définis : si la méthode renvoie une valeur (influencant l'uitlisation du mot-clé void) et les types des paramètres.

// Exemples de définition et d'appel de méthodes
1. Méthode avec paramètres et valeur de retour
    // Définition : public static type_retour nom_méthode(type_param paramètre) { ... return valeur; }
    // Appel : type_retour variable = nom_méthode(paramètres);
    public class Exemple {
        public static void main(String[] args) {
            int[] donnees = {3, 8, -2, 5, 0};
            boolean contientNegatif = verifierNegatif(donnees);
            System.out.println("Contient négatif : " + contientNegatif);

            int plusPetit = trouverMinimum(donnees);
            System.out.println("Valeur minimale : " + plusPetit);

            double moyenne = calculerMoyenne(donnees);
            System.out.println("Moyenne : " + moyenne);
        }

        // Vérifie si le tableau contient des valeurs négatives
        public static boolean verifierNegatif(int[] tableau) {
            for (int element : tableau) {
                if (element < 0) {
                    return true;
                }
            }
            return false;
        }

        // Trouve la valeur minimale dans le tableau
        public static int trouverMinimum(int[] tableau) {
            int min = Integer.MAX_VALUE;
            for (int element : tableau) {
                if (element < min) {
                    min = element;
                }
            }
            return min;
        }

        // Calcule la moyenne des éléments du tableau
        public static double calculerMoyenne(int[] tableau) {
            int somme = 0;
            for (int element : tableau) {
                somme += element;
            }
            return (double) somme / tableau.length;
        }
    }

2. Méthode avec paramètres sans valeur de retour (utilisation de void)
    public static void main(String[] args) {
        String prenom = "Alice";
        afficherMessage(prenom);
    }
    
    public static void afficherMessage(String nom) {
        System.out.println("Bonjour, " + nom + " !");
    }

3. Méthode sans paramètres avec valeur de retour
    public static void main(String[] args) {
        String salutation = obtenirSalutation();
        System.out.println(salutation);
    }
    
    public static String obtenirSalutation() {
        return "Bienvenue en Java";
    }

4. Méthode sans paramètres sans valeur de retour
    public static void main(String[] args) {
        executerTache();
    }
    
    public static void executerTache() {
        System.out.println("Exécution d'une tâche sans entrée ni sortie.");
    }

// Format général
    Définition : public static type_retour nom_méthode(type_param1 param1, type_param2 param2) { ... }
    Appel : type_retour variable = nom_méthode(param1, param2);

Points à Noter pour les Méthodes

1. Définir clairement le retour (avec ou sans return) et les types des paramètres avant de créer la méthode.
2. Lors de la définition, indiquer le type pour chaque paramètre ; lors de l'appel, omettre les types.
3. Les méthodes ne peuvent pas être imbriquées les unes dans les autres.
4. Avec le mot-clé void, la méthode ne renvoie pas de valeur, mais return (sans donnée) peut être utilisé pour terminer son exécution prématurément.

Surcharge des Méthodes

La surhcarge permet de définir plusieurs méthodes avec le même nom dans une classe, à condition que leurs signatures (types ou nombres de paramètres) diffèrent. Cela facilite la gestion de divers types d'entrées.

// Exemple de surcharge
public class SurchargeExemple {
    public static void main(String[] args) {
        int a = 5, b = 10;
        float c = 3.5f, d = 7.2f;
        long e = 100L, f = 200L;
        
        System.out.println("Max int : " + trouverMax(a, b));
        System.out.println("Max float : " + trouverMax(c, d));
        System.out.println("Max long : " + trouverMax(e, f));
    }

    // Méthode pour entiers
    public static int trouverMax(int x, int y) {
        return (x > y) ? x : y;
    }

    // Méthode pour flottants
    public static float trouverMax(float x, float y) {
        return (x > y) ? x : y;
    }

    // Méthode pour longs
    public static long trouverMax(long x, long y) {
        return (x > y) ? x : y;
    }
}

Passage de Paramètres des Méthodes

Conclusions :
1. Pour les types primitifs, la modification via paramètre n'affecte pas la valeur originale.
    // Démonstration
    public static void main(String[] args) {
        int valeur = 5;
        System.out.println("Avant modification : " + valeur);
        modifierValeur(valeur);
        System.out.println("Après modification : " + valeur);
    }
    
    public static void modifierValeur(int val) {
        val = 20; // Modification locale seulement
    }
    // Sortie : 5 avant et après.

2. Pour les types référentiels, la modification via paramètre change la valeur originale.
    // Démonstration avec un tableau
    public static void main(String[] args) {
        int[] tableau = {10, 20, 30};
        System.out.println("Avant modification : " + tableau[0]);
        modifierTableau(tableau);
        System.out.println("Après modification : " + tableau[0]);
    }
    
    public static void modifierTableau(int[] tab) {
        tab[0] = 99; // Modification affecte l'objet original
    }
    // Sortie : 10 avant, 99 après.

Diagramme de Mémoire lors de l'Exécution des Méthodes

Lors de l'appel d'une méthode, la pile d'exécution (stack) gère les variables locales et les apels. Les objets référentiels sont stockés dans le tas (heap), avec des références dans la pile. Cela explique les différences de comportement entre types primitifs et référentiels dans le passage de paramètres.