Méthodes Java : comment définir et appeler des méthodes

Pourquoi les méthodes existent

Une méthode est un bloc de code nommé que vous pouvez exécuter chaque fois que vous appelez son nom. Au lieu d'écrire les mêmes lignes encore et encore, vous les écrivez une seule fois dans une méthode et vous l'appelez autant de fois que nécessaire. Cela rend les programmes plus courts, plus faciles à lire et bien plus faciles à corriger : vous changez la logique en un seul endroit et tous les appelants reçoivent la mise à jour.

Vous appelez déjà des méthodes : System.out.println(...) est un appel de méthode, et list.size() aussi. Maintenant, vous allez écrire les vôtres.

Déclarer et appeler une méthode

La déclaration d'une méthode comporte quatre parties : un type de retour, un nom, une paire de parenthèses (pour les paramètres) et un corps entre accolades. Voici le plus petit exemple utile : une méthode qui fait un peu de travail et ne renvoie rien :

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // appelez-la
        printGreeting();   // appelez-la à nouveau
    }
}

Lisez les éléments de static void printGreeting() :

• static : permet à main de l'appeler directement sans créer d'objet (plus de détails ci-dessous).
• void : cette méthode ne renvoie aucune valeur.
• printGreeting : le nom que vous utilisez pour l'appeler.
• () : des parenthèses vides signifient qu'elle ne prend aucune entrée.

Vous appelez une méthode en écrivant son nom suivi de parenthèses. Les deux appels dans main exécutent le corps deux fois, donc cela affiche la salutation deux fois.

Renvoyer une valeur

La plupart des méthodes calculent quelque chose et le renvoient avec return. Le type de retour placé avant le nom indique quel genre de valeur sort ; ici, int :

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) s'évalue à 25, que vous pouvez stocker dans une variable, afficher ou utiliser dans une expression plus grande : un appel de méthode tient lieu de la valeur qu'il renvoie. Dès que return s'exécute, la méthode se termine et le contrôle revient à l'appelant. Tout code situé après un return sur le même chemin ne s'exécute jamais.

Le type de retour et la valeur renvoyée doivent correspondre. Déclarer int et essayer return "text"; est une erreur de compilation : le compilateur fait respecter le contrat.

void par rapport à un type de retour

La distinction est simple : utilisez un vrai type de retour quand l'appelant a besoin de récupérer une valeur, et void quand la méthode se contente de faire quelque chose (afficher, enregistrer, mettre à jour l'état).

void logMessage(String msg)   // fait le travail, ne renvoie rien
int  add(int a, int b)        // calcule une valeur que l'appelant utilise

Une erreur fréquente chez les débutants est d'essayer d'utiliser le « résultat » d'une méthode void :

int x = printGreeting();   // erreur de compilation : printGreeting() renvoie void

Il n'y a aucune valeur à affecter, donc cela ne compile pas. Si vous vous surprenez à vouloir le résultat d'une méthode void, c'est le signe qu'elle devrait plutôt renvoyer quelque chose.

Méthodes qui se ramifient et renvoient tôt

Vous pouvez utiliser return à plus d'un endroit. Renvoyer tôt, dès que vous connaissez la réponse, se lit souvent plus clairement que d'imbriquer tout dans des else :

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Comme chaque return sort immédiatement, la première condition satisfaite l'emporte. Assurez-vous simplement que tout chemin à travers une méthode qui renvoie une valeur se termine par un return : si une branche peut aboutir sans rien renvoyer, le compilateur se plaint avec « missing return statement ». Le return "F"; final couvre ici le cas de sortie par défaut.

Ce que static signifie ici

Vous avez peut-être remarqué que toutes les méthodes ci-dessus sont static. Une méthode static appartient à la classe elle-même, pas à un objet, donc main (qui est lui aussi static) peut l'appeler directement par son nom. Sans static, la méthode appartient à une instance et il vous faudrait un objet sur lequel l'appeler.

Pour l'instant, tant que vous écrivez de petits programmes dont la logique cohabite avec main, marquez vos méthodes utilitaires comme static pour qu'elles puissent être appelées de la même façon. Une fois que vous commencerez à construire vos propres classes et objets, vous écrirez aussi des méthodes non statiques (d'instance) : cela viendra avec le chapitre sur les classes.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main est static, il peut donc appeler doubleIt directement
        System.out.println(doubleIt(21));   // 42
    }
}

Les variables locales restent à l'intérieur de la méthode

Les variables déclarées à l'intérieur d'une méthode n'existent que là. Elles sont créées quand la méthode s'exécute et disparaissent quand elle se termine : l'appelant ne les voit jamais :

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // locale à sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // erreur : total n'est pas visible ici
    }
}

total et i vivent entièrement à l'intérieur de sumTo. La seule chose qui s'échappe de la méthode est la valeur que vous return. Cet isolement est un atout : chaque méthode est une unité autonome sur laquelle vous pouvez raisonner sans craindre que ses variables temporaires fuient ou entrent en collision avec des noms ailleurs.

Suivant : les paramètres de méthode

Chaque méthode ici ne prenait soit aucune entrée, soit une seule valeur. La véritable puissance vient du passage de données en entrée, et Java possède des règles précises sur la manière dont les arguments sont passés, ce qui se passe avec les objets par rapport aux primitives, et comment donner à un paramètre une sorte de valeur par défaut. C'est l'objet de la page suivante.