Aller au contenu principal

Les méthodes

Notions théoriques​

Qu'est-ce qu'une méthode ?​

Une méthode est un bloc de code réutilisable qui effectue une tâche précise. Elle permet d'éviter de répéter du code et de structurer un programme. En PHP on parle de "fonction", en Java on parle de "méthode" car elle appartient toujours à une classe.

Méthodes statiques​

Avant d'étudier la POO, nous utilisons des méthodes statiques (static). Une méthode statique appartient à la classe, pas à un objet particulier. C'est aussi pour ça que la méthode main est static.

Structure d'une méthode​

public static typeDeRetour nomDeLaMéthode(TypeParam1 param1, TypeParam2 param2) {
    // corps de la méthode
    return valeur; // si le type de retour n'est pas void
}
  • public : la méthode est accessible de partout
  • static : méthode de classe (pas d'objet nécessaire)
  • typeDeRetour : le type de la valeur retournée (int, String, double, etc.) ou void si rien n'est retourné
  • nomDeLaMéthode : en camelCase
  • (TypeParam nom) : les paramètres avec leur type

Exemple de méthodes​

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

// Méthode avec paramètres, sans retour
public static void afficherNom(String prenom, String nom) {
    System.out.println("Bonjour " + prenom + " " + nom + " !");
}

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

// Méthode avec retour String
public static String getMention(double note) {
    if (note >= 16) return "Très Bien";
    if (note >= 14) return "Bien";
    if (note >= 12) return "Assez Bien";
    if (note >= 10) return "Passable";
    return "Insuffisant";
}

Le mot-clé return​

return sert à retourner une valeur et à quitter la méthode immédiatement. Si le type de retour est void, on peut utiliser return; (sans valeur) pour quitter prématurément.

La surcharge (overloading)​

Java permet de définir plusieurs méthodes portant le même nom mais avec des paramètres différents. C'est ce qu'on appelle la surcharge :

public static int additionner(int a, int b) {
    return a + b;
}

public static double additionner(double a, double b) {
    return a + b;
}

public static int additionner(int a, int b, int c) {
    return a + b + c;
}

Java choisit automatiquement la bonne méthode selon le type et le nombre des arguments passés.

Portée des variables locales​

Une variable déclarée à l'intérieur d'une méthode est locale à cette méthode. Elle n'existe pas en dehors de la méthode.

public static void maMethode() {
    int x = 10;  // variable locale à maMethode
}
// x n'existe plus ici

Documentation avec Javadoc​

La documentation officielle Java s'écrit avec des commentaires /** ... */ juste avant la méthode :

/**
 * Calcule la somme de deux entiers.
 *
 * @param a Le premier entier.
 * @param b Le deuxième entier.
 * @return La somme de a et b.
 */
public static int additionner(int a, int b) {
    return a + b;
}
Javadoc dans IntelliJ

Dans IntelliJ, tapez /** juste avant une méthode et appuyez sur Entrée : IntelliJ génère automatiquement la structure Javadoc avec les @param et @return.

Exemple pratique​

public class Calculatrice {

    /**
     * Additionne deux entiers.
     */
    public static int additionner(int a, int b) {
        return a + b;
    }

    /**
     * Calcule le périmètre d'un rectangle.
     * @param largeur La largeur du rectangle.
     * @param hauteur La hauteur du rectangle.
     * @return Le périmètre.
     */
    public static double perimetre(double largeur, double hauteur) {
        return 2 * (largeur + hauteur);
    }

    /**
     * Retourne true si un nombre est pair.
     */
    public static boolean estPair(int nombre) {
        return nombre % 2 == 0;
    }

    /**
     * Retourne la plus grande des deux valeurs.
     */
    public static int max(int a, int b) {
        if (a > b) return a;
        return b;
    }

    public static void main(String[] args) {
        int somme = additionner(5, 3);
        System.out.println("5 + 3 = " + somme);

        double p = perimetre(10.0, 5.0);
        System.out.println("Périmètre du rectangle : " + p);

        System.out.println("12 est pair ? " + estPair(12));
        System.out.println("7 est pair ? " + estPair(7));

        System.out.println("Max(8, 3) = " + max(8, 3));
    }
}
astuce

Appelez une méthode en écrivant son nom suivi des arguments entre parenthèses. Si la méthode est dans la même classe, vous n'avez pas besoin de préciser le nom de la classe.

Test de mémorisation/compréhension​


Quel type de retour doit avoir une méthode qui ne retourne rien ?


Pourquoi déclare-t-on les méthodes avec 'static' avant d'étudier la POO ?


Qu'est-ce que la surcharge (overloading) ?


Quelle est la portée d'une variable déclarée à l'intérieur d'une méthode ?


Quel commentaire est utilisé pour documenter une méthode en Java (Javadoc) ?


Comment s'écrit la convention de nommage des méthodes en Java ?


TP pour réfléchir et résoudre des problèmes​

Vous allez créer une classe OutilsNotes avec des méthodes utilitaires pour gérer les notes d'un lycéen.

Étape 1 — Méthode calculerMoyenne​

Crée une méthode statique qui prend trois notes double en paramètre et retourne leur moyenne.


Bonne pratique - Une méthode = une responsabilité

La méthode calculerMoyenne ne fait qu'une seule chose : calculer. Elle ne fait pas d'affichage. Cette séparation des responsabilités rend le code plus testable et réutilisable.

Étape 2 — Méthode getMention​

Crée une méthode qui retourne la mention (String) correspondant à une note (double).


Bonne pratique - return en milieu de méthode

Il est tout à fait correct d'avoir plusieurs return dans une méthode. Dès qu'un return est exécuté, la méthode s'arrête. Cette technique évite des else if imbriqués et rend le code plus lisible.

Étape 3 — Appel des méthodes dans main​

Dans la méthode main, appelez calculerMoyenne et getMention pour afficher le bilan d'un étudiant.


Bonne pratique - Stocker le résultat dans une variable

Quand vous appelez une méthode qui retourne une valeur et que vous l'utilisez plusieurs fois, stockez le résultat dans une variable. Cela évite d'appeler la méthode plusieurs fois et rend le code plus lisible.

📌 Une solution