Introduction aux Méthodes Java

En programmation Java, une méthode est un bloc de code ou un ensemble d'instructions regroupées pour effectuer une tâche ou une opération spécifique. C'est un concept fondamental pour organiser le code, le rendre réutilisable et faciliter la maintenance des applications. Par exemple, dans l'expression courante System.out.println(), System est une classe, out est un objet, et println est la méthode qui imprime du texte sur la console.

Les méthodes sont créées au sein des classes et peuvent être invoquées depuis d'autres parties du programme. Elles encapsulent la logique métier, améliorant ainsi la modularité du code. Un principe de conception clé est l'atomicité : une méthode devrait idéalement n'accomplir qu'une seule tâche bien définie.

Exemple de Définition et d'Appel de Méthodes

Voici un exemple simple illustrant la définition de méthodes pour l'addition et l'affichage d'un message, puis leur appel depuis la méthode principale main.

public class DemonstrationMethodes {

    // La méthode principale, point d'entrée de l'application
    public static void main(String[] args) {
        // Appel d'une méthode retournant une valeur
        int resultatAddition = additionner(10, 20);
        System.out.println("La somme de 10 et 20 est : " + resultatAddition);

        // Appel d'une méthode sans valeur de retour
        afficherSalutation("Développeur Java");

        // Utilisation d'une autre méthode
        afficherForme();
    }

    /**
     * Effectue l'addition de deux nombres entiers.
     * @param operande1 Le premier nombre.
     * @param operande2 Le second nombre.
     * @return La somme des deux nombres.
     */
    public static int additionner(int operande1, int operande2) {
        return operande1 + operande2;
    }

    /**
     * Affiche un message de salutation personnalisé.
     * @param nom L'entité à saluer.
     */
    public static void afficherSalutation(String nom) {
        System.out.println("Bonjour, " + nom + "! Bienvenue dans l'univers Java.");
    }

    /**
     * Affiche une simple forme géométrique sur la console.
     */
    public static void afficherForme() {
        System.out.println("*****");
        System.out.println(" *   *");
        System.out.println("  * *");
        System.out.println("   *");
    }
}

Surcahrge de Méthodes (Method Overloading)

La surcharge de méthodes permet de définir plusieurs méthodes avec le même nom au sein d'une même classe, à condition que leurs listes de paramètres (leur signature) soient différentes. Cela offre une grande flexibilité en permettant à une méthode d'agir différemment selon le type ou le nombre d'arguments qu'elle reçoit.

Règles de Surcharge :

• **Nom de la méthode** : Doit être identique.
• **Liste de paramètres** : Doit différer. Les différences peuvent porter sur :
  • Le nombre de paramètres.
  • Le type des paramètres.
  • L'ordre des types de paramètres.
• **Type de retour** : Peut être identique ou différent, mais une différence de type de retour seule n'est pas suffisante pour surcharger une méthode.

Exemple de Surcharge :

Considérons une méthode afficherInformation qui peut traiter différents types d'informations :

public class SurchargeMethodes {

    public static void main(String[] args) {
        // Appel de la première version : String
        afficherInformation("Ceci est un message simple.");

        // Appel de la deuxième version : String et int
        afficherInformation("Attention requise !", 3);

        // Appel de la troisième version : int et String
        afficherInformation(12345, "Identifiant produit :");
    }

    /**
     * Affiche une simple information textuelle.
     * @param message Le texte à afficher.
     */
    public static void afficherInformation(String message) {
        System.out.println("Info: " + message);
    }

    /**
     * Affiche une information textuelle répétée plusieurs fois.
     * @param message Le texte à afficher.
     * @param repetitions Le nombre de fois que le texte doit être affiché.
     */
    public static void afficherInformation(String message, int repetitions) {
        System.out.println("--- Répétitions ---");
        for (int i = 0; i < repetitions; i++) {
            System.out.println((i + 1) + ". " + message);
        }
        System.out.println("-------------------");
    }

    /**
     * Affiche un nombre précédé d'un préfixe.
     * @param valeur Le nombre à afficher.
     * @param prefixe Le préfixe à utiliser.
     */
    public static void afficherInformation(int valeur, String prefixe) {
        System.out.println(prefixe + " " + valeur);
    }
}

Paramètres Variables (Varargs)

Les paramètres variables, ou "varargs", sont une fonctionnalité de Java qui permet à une méthode d'accepter un nombre variable d'arguments du même type. Ceci est particulièrement utile lorsque vous ne connaissez pas à l'avance le nombre d'arguments qui seront passés à la méthode.

Utilisation des Varargs :

• Un paramètre variable est déclaré en ajoutant trois points (...) après le type de données (ex: double... nombres).
• Une méthode ne peut avoir qu'un seul paramètre variable.
• Si d'autres paramètres sont présents, le paramètre variable doit être le dernier dans la liste des paramètres de la méthode.
• En interne, le compilateur Java traite le paramètre variable comme un tableau (array) du type spécifié.

Exemple de Méthode avec Varargs :

Nous pouvons utiliser les varargs pour calculer la moyenne d'un ensemble de nombres, quelle que soit leur quantité :

public class GestionParametresVariables {

    public static void main(String[] args) {
        System.out.println("Moyenne des valeurs (10.0, 20.0, 30.0) : " + calculerMoyenne(10.0, 20.0, 30.0));
        System.out.println("Moyenne des valeurs (5.0, 15.0) : " + calculerMoyenne(5.0, 15.0));
        System.out.println("Moyenne d'une seule valeur (75.0) : " + calculerMoyenne(75.0));
        System.out.println("Moyenne d'aucun nombre : " + calculerMoyenne());
    }

    /**
     * Calcule la moyenne arithmétique d'un ensemble de nombres.
     * @param valeurs Une série de nombres de type double.
     * @return La moyenne des nombres, ou 0.0 si aucune valeur n'est fournie.
     */
    public static double calculerMoyenne(double... valeurs) {
        if (valeurs.length == 0) {
            System.out.println("Avertissement : Aucune valeur fournie pour le calcul de la moyenne.");
            return 0.0;
        }

        double somme = 0;
        for (double val : valeurs) {
            somme += val;
        }
        return somme / valeurs.length;
    }
}

Récursion

La récursion est une technique de programmation où une fonction ou une méthode s'appelle elle-même pour résoudre un problème. Un problème est résolu de manière récursive en le décomposant en sous-problèmes plus petits, jusqu'à atteindre un cas de base simple qui peut être résolu directement.

Structure d'une Fonction Récursive :

Une fonction récursive se compose généralement de deux parties essentielles : - **Cas de base (ou Condition d'arrêt)** : C'est la condition qui spécifie quand la méthode ne doit plus s'appeler elle-même. Sans un cas de base correctement défini, la récursion aboutirait à une boucle infinie et une erreur de dépassement de pile (StackOverflowError).

• **Étape récursive** : C'est la partie où la méthode s'appelle elle-même avec des arguments modifiés, travaillant vers le cas de base.

Exemple de Récursion : la Suite de Fibonacci

La suite de Fibonacci est un excellent exemple pour illustrer la récursion, où chaque nombre est la somme des deux précédents (F(n) = F(n-1) + F(n-2)), avec F(0)=0 et F(1)=1 comme cas de base.

public class CalculRecursif {

    public static void main(String[] args) {
        int index1 = 7; // Calculer le 7ème nombre de Fibonacci
        System.out.println("Le " + index1 + "ème nombre de Fibonacci est : " + fibonacci(index1));

        int index2 = 10;
        System.out.println("Le " + index2 + "ème nombre de Fibonacci est : " + fibonacci(index2));
    }

    /**
     * Calcule le n-ième nombre de la suite de Fibonacci de manière récursive.
     * La suite est définie par F(0) = 0, F(1) = 1, et F(n) = F(n-1) + F(n-2) pour n > 1.
     * @param n L'indice du nombre de Fibonacci à calculer.
     * @return Le n-ième nombre de Fibonacci.
     */
    public static long fibonacci(int n) {
        // Cas de base : Les deux premiers nombres de Fibonacci
        if (n <= 1) {
            return n;
        }
        // Étape récursive : La somme des deux nombres précédents
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}