Méthodes Java et décomposition d’un programme

Une méthode est un bloc d’instructions nommé qui accomplit une tâche. Définir une méthode rend cette tâche disponible ; l’appeler exécute la tâche.

Lis l’en-tête et le corps

public static void printLine() {
    System.out.println("----------");
}

La première ligne est l’en-tête. Lis ses éléments de gauche à droite :

• public permet au code d’autres classes d’appeler la méthode.
• static fait appartenir la méthode à la classe. Aucun objet n’est nécessaire pour l’appeler.
• void indique que la méthode ne renvoie aucune valeur.
• printLine donne un nom à la tâche.
• () est la liste vide des paramètres : cette méthode n’a besoin d’aucune donnée en entrée.

Les accolades entourent le corps, c’est-à-dire les instructions exécutées lors d’un appel. Il n’y a pas de point-virgule entre cet en-tête et son accolade ouvrante.

Place la définition dans la classe

public class Main {
    public static void main(String[] args) {
        System.out.println("Start");
        printLine();
        System.out.println("Middle");
        printLine();
    }

    public static void printLine() {
        System.out.println("----------");
    }
}

main et printLine sont deux méthodes distinctes dans Main. L’accolade fermante de main précède la définition de printLine. Une méthode ne peut pas être définie dans une autre méthode ; une accolade mal placée peut produire « illegal start of expression ».

Les définitions peuvent apparaître dans l’un ou l’autre ordre. Déplacer printLine au-dessus de main ne change pas le moment où elle s’exécute. Une méthode qui n’est jamais appelée ne s’exécute pas simplement parce que sa définition figure dans le fichier.

Suis un appel et le retour au code appelant

L’appel printLine(); comprend le nom, les parenthèses et un point-virgule, car l’appel constitue une instruction à lui seul. L’exécution commence dans main :

1. Afficher « Start ».
2. Entrer dans printLine, afficher dix tirets, puis reprendre après l’appel.
3. Afficher « Middle ».
4. Entrer à nouveau dans printLine et afficher à nouveau dix tirets.

La sortie est :

Start
----------
Middle
----------

Les deux appels utilisent la même définition. Modifier la ligne qu’elle affiche modifie les deux endroits où elle est utilisée.

Nomme et appelle les méthodes correctement

Utilise un verbe ou un groupe verbal en camelCase, en commençant par une minuscule : printReceipt, calculateAverage ou isValidCode. Java distingue les majuscules des minuscules : PrintLine() ne trouve pas une méthode nommée printLine. Écrire printLine; échoue également ; les parenthèses font partie de l’appel.

Pour une méthode statique d’une autre classe, écris d’abord le nom de la classe. Math.max(3, 8) donne 8, Math.abs(-4) donne 4 et Math.sqrt(16.0) donne 4.0. Tes propres méthodes dans la même classe peuvent être appelées par leur seul nom.

Ces exemples utilisent la forme classique fondée sur une classe avec public static void main(String[] args). Java 25 prend aussi en charge les fichiers source compacts avec void main() et sans classe englobante. Garde la forme classique pour exécuter ces exemples ; ses méthodes auxiliaires sont déclarées static. Les méthodes que tu appelles depuis la bibliothèque Java, comme System.out.println, n’ont pas nécessairement à être statiques elles-mêmes.

Un paramètre permet à une méthode de traiter des valeurs qui changent d’un appel à l’autre. Un argument est la valeur fournie pour ce paramètre lors de l’appel de la méthode.

Donne un type et un nom à chaque entrée

public static void printStars(int count) {
    for (int i = 0; i < count; i++) {
        System.out.print("*");
    }
    System.out.println();
}

int count déclare un paramètre. Dans printStars(3);, l’argument 3 devient la valeur initiale de count. La boucle s’exécute trois fois et affiche donc ***, puis println() termine la ligne. printStars(8); utilise le même corps avec count égal à 8.

Le type s’écrit dans la définition, pas dans l’appel. Écris printStars(5);, pas printStars(int 5);.

Évalue les arguments avant d’entrer dans le corps

Un argument peut être un littéral, une variable ou une expression :

int n = 4;
printStars(n * 2);

Java évalue d’abord n * 2. Il transmet la valeur obtenue, 8 : le corps commence donc avec count égal à 8. Le nom de la variable du code appelant n’a pas besoin de correspondre à celui du paramètre.

Fais correspondre plusieurs paramètres par position

Chaque paramètre doit avoir son propre type. Une méthode qui dessine un rectangle peut commencer par cet en-tête :

public static void printRectangle(int width, int height)

L’appel printRectangle(5, 2); donne à width la valeur 5 et à height la valeur 2. Inverser les arguments donne un rectangle de 2 de large et 5 de haut. Les deux appels compilent car les deux arguments sont des int ; seule la forme voulue permet de savoir quel ordre est correct. Écrire (int width, height) dans l’en-tête échoue car aucun type n’est déclaré pour height.

Des types différents rendent certaines erreurs d’ordre plus faciles à repérer :

public static void printRepeated(String text, int times) {
    for (int i = 0; i < times; i++) {
        System.out.print(text);
    }
    System.out.println();
}

printRepeated("ab", 3); affiche « ababab ». printRepeated(3, "ab"); ne peut pas correspondre à un String suivi d’un int. Le nombre d’arguments doit aussi correspondre : printRectangle(5); laisse un paramètre sans valeur.

Vérifie la compatibilité des types numériques

Java effectue automatiquement une conversion élargissante d’un int en double. Une méthode avec les paramètres (double km, double hours) accepte les arguments (150, 2) et reçoit 150.0 et 2.0. Toute valeur int peut être représentée exactement sous forme de double.

Java n’effectue pas implicitement de conversion réductrice d’un argument double pour un paramètre int. printStars(2.9); échoue car la conversion ferait perdre la partie fractionnaire. Le transtypage explicite dans printStars((int) 2.9); produit 2 : deux étoiles sont donc affichées. Utilise un transtypage seulement lorsque tu souhaites supprimer cette partie.

Choisis un paramètre pour chaque information nécessaire à la tâche. Recevoir du texte et un nombre permet d’utiliser printRepeated avec une saisie au clavier, un appel de test fixe ou une autre méthode. Son corps n’a pas à décider d’où viennent ces valeurs.

Une valeur de retour est un résultat transmis par une méthode au code qui l’a appelée. Une fois l’appel terminé, il peut être utilisé comme une expression du type de ce résultat.

Déclare ce qui est renvoyé

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

int remplace void dans l’en-tête car cette méthode renvoie un entier. L’instruction return évalue a + b et transmet la valeur à l’endroit de l’appel. Pour sum(4, 7), cette valeur est 11.

Le code appelant décide de la suite :

int total = sum(4, 7);
System.out.println(sum(4, 7));
int doubled = sum(2, 3) * 2;

La première ligne stocke 11 ; la deuxième affiche 11 ; la troisième stocke 10. Une valeur renvoyée peut aussi être utilisée dans une condition, comme if (sum(a, b) > 10).

Un résultat int compatible peut subir une conversion élargissante lorsqu’il est renvoyé par une méthode de type double. Un résultat double ne peut pas être renvoyé par une méthode de type int sans conversion explicite appropriée.

Calcule l’expression avant de convertir le résultat

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

Pour average(3, 4), le numérateur vaut 7. La division par le littéral double 2.0 donne 3.5. Si l’expression était (a + b) / 2, Java diviserait d’abord deux int et obtiendrait 3. Ce n’est qu’ensuite qu’il effectuerait une conversion élargissante de cette valeur pour renvoyer 3.0. Un type de retour double ne corrige pas une division entière déjà effectuée dans le corps.

Distingue le retour de l’affichage

Un appel void ne peut pas fournir une valeur dans une affectation ou un autre appel. Si printSum est de type void, int total = printSum(1, 2); échoue même si printSum affiche un nombre. Utilise une méthode qui renvoie une valeur pour les calculs et laisse le code appelant décider s’il faut l’afficher.

Renvoie du texte et des réponses par oui ou par non

Les types de retour comprennent aussi String et boolean. Une méthode de salutation peut renvoyer "Hello, " + name + "!", ce qui donne « Hello, Ana! » pour l’argument "Ana". Une méthode isEven(int n) peut renvoyer n % 2 == 0.

Une méthode de formatage transforme un nombre en texte réutilisable :

public static String formatDuration(int minutes) {
    return minutes / 60 + " h " + minutes % 60 + " min";
}

Pour 135, la division entière donne 2 heures entières et le reste donne 15 minutes. Le résultat est « 2 h 15 min » ; pour 60, c’est « 1 h 0 min ».

Conserve ou combine le résultat

Un appel tel que sum(4, 7); compile, mais abandonne son résultat. Si square(x) renvoie une nouvelle valeur, utilise x = square(x); pour la stocker dans x.

Un résultat peut aussi devenir directement un argument. Dans Math.max(sum(1, 2), 4), sum(1, 2) donne d’abord 3, puis Math.max(3, 4) donne 4. Évalue l’appel interne avant d’utiliser son résultat dans l’appel externe.

Une instruction return termine immédiatement l’appel de méthode en cours. Dans une condition ou une boucle, elle quitte toujours la méthode entière, pas seulement ce bloc.

Donne une réponse à chaque chemin

public static int larger(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

larger(9, 4) renvoie 9 depuis le if. Pour larger(2, 6), le corps du if est ignoré et le return final donne 6. Des entrées égales comme (5, 5) atteignent aussi le return final, qui donne 5. Aucun else n’est nécessaire après le premier return, car ce chemin a déjà quitté la méthode.

Dans une méthode ordinaire qui renvoie une valeur, aucun chemin possible ne doit atteindre l’accolade fermante sans fournir de valeur. Une méthode qui indique le signe et ne renvoie une valeur que pour les entrées positives et négatives laisse zéro sans réponse :

public static String sign(int n) {
    if (n > 0) {
        return "positive";
    } else if (n < 0) {
        return "negative";
    }
    return "zero";
}

Le return final complète la méthode. Deux instructions if distinctes, l’une testant n > 0 et l’autre n <= 0, nécessitent toujours un return final ou une structure if/else explicite. Lorsqu’il vérifie les retours, Java ne déduit pas que ces deux comparaisons couvrent tous les entiers. Une instruction placée directement après un return inconditionnel dans le même bloc est inaccessible et rejetée.

Termine une recherche au bon moment

public static int firstMultipleOf7(int start, int end) {
    for (int i = start; i <= end; i++) {
        if (i % 7 == 0) {
            return i;
        }
    }
    return -1;
}

Pour (10, 20), la boucle rejette 10, 11, 12 et 13, puis renvoie 14. L’appel se termine sans vérifier les nombres de 15 à 20. Pour (15, 20), la boucle se termine sans trouver de correspondance : le return placé après elle donne donc -1, la valeur convenue pour signaler « non trouvé ».

Placer else { return -1; } dans la boucle entraînerait une sortie après le premier candidat rejeté. La recherche à partir de 10 signalerait alors un échec avant d’atteindre 14. Le retour signalant l’échec doit venir après l’examen de tous les candidats.

Renvoie la condition elle-même

Une comparaison produit déjà un booléen. Écris return n % 2 == 0; au lieu d’un if/else qui renvoie séparément true et false. Le nom d’une méthode booléenne commence souvent par is ou has, de sorte qu’un appel se lit naturellement dans un if.

public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;
}

Cette méthode renvoie true pour 2024 et 2000, mais false pour 1900 et 2023. Utilise directement if (isLeapYear(y)).

Quitte une méthode void de manière anticipée

Une méthode void utilise return; sans valeur. Par exemple, printSquareRoot(double x) peut afficher « No real square root » et se terminer immédiatement pour une entrée négative. Pour les autres entrées, elle peut afficher Math.sqrt(x), qui donne 1.5 pour 2.25. Écrire return 5; dans une méthode void échoue car son en-tête indique qu’elle ne renvoie aucune valeur.

La portée d’une variable est la zone du code où son nom peut être utilisé. Commence par les accolades qui entourent sa déclaration : un nom local appartient à une méthode ou à un bloc précis.

Les variables locales du code appelant restent dans celui-ci

public static void main(String[] args) {
    int price = 20;
    printDouble(price);
}

public static void printDouble(int price) {
    System.out.println(price * 2);
}

Le price de main et le paramètre price de printDouble sont des variables distinctes. L’argument fournit la valeur dont la méthode auxiliaire a besoin, qui affiche donc 40.

Supprimer le paramètre et appeler printDouble() ne permet pas à la méthode auxiliaire de lire la variable locale price de main. Son corps échouerait avec « cannot find symbol ». Appeler une méthode depuis une autre ne réunit pas leurs portées. Des méthodes différentes peuvent chacune utiliser le nom count sans que leurs variables soient liées.

Un bloc imbriqué crée une portée plus petite

Une variable locale peut être utilisée de sa déclaration jusqu’à l’accolade fermante de son bloc. Un paramètre est disponible dans tout le corps de sa méthode. Un compteur déclaré dans for (int i = 0; i < 3; i++) appartient à cette boucle ; i ne peut pas être lu après celle-ci.

Pour conserver un résultat après une boucle, déclare-le avant la boucle :

int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
System.out.println(sum);

Les additions donnent successivement à sum les valeurs 1, 3, 6, 10 et 15. L’instruction d’affichage finale peut lire sum car le bloc englobant n’est pas terminé. i n’est nécessaire que pour la boucle et reste dans sa portée.

Déplacer int sum = 0; dans le corps de la boucle crée un nouveau sum à chaque passage. Chacun commence à zéro et disparaît à la fin de ce passage. Il ne peut pas conserver une somme cumulée ni être affiché après la boucle.

Vérifie séparément les noms et les valeurs initiales

Deux variables locales de même nom ne peuvent pas avoir des portées qui se chevauchent dans une même méthode. Une méthode ayant un paramètre x ne peut pas déclarer une autre variable locale x ; une boucle qui déclare i ne peut pas déclarer un autre i dans son corps. Renomme la seconde variable ou utilise celle qui existe déjà.

Deux boucles successives peuvent chacune déclarer int i. La portée de la première boucle est terminée avant la seconde déclaration. Ce sont les accolades, et non le fichier entier, qui déterminent cette possibilité de réutilisation.

Un nom autorisé doit aussi avoir une valeur avant d’être lu. int total; total++; échoue car ++ doit lire l’ancienne valeur et une variable locale ne reçoit pas automatiquement de valeur initiale. Utilise int total = 0; pour une somme cumulée.

Garde une variable locale dans le plus petit bloc où elle est nécessaire. Si une méthode a besoin d’une information du code appelant, fais-en un paramètre. Si le code appelant a besoin d’un résultat, renvoie-le. L’en-tête et le corps de la méthode montrent alors d’où viennent ses données.

Java transmet les arguments par valeur. Au début d’un appel, chaque paramètre reçoit une copie de la valeur de son argument. Une affectation au paramètre modifie cette variable locale.

Suis la copie séparément

public static void main(String[] args) {
    int score = 10;
    addBonus(score);
    System.out.println(score);
}

public static void addBonus(int score) {
    score = score + 5;
    System.out.println(score);
}

Il y a deux variables appelées score. Suis leurs valeurs à chaque étape :

La méthode auxiliaire affiche 15, puis main affiche 10. Le fait de partager un nom ne signifie pas que les deux variables partagent leur emplacement de stockage. Renommer le paramètre ne changerait pas ce comportement.

Renvoie la nouvelle valeur et stocke-la

public static int addBonus(int score) {
    return score + 5;
}

Avec cette version, écris score = addBonus(score);. Java copie l’ancienne valeur dans le paramètre, calcule 15, renvoie cette valeur et l’affecte à la variable du code appelant. C’est l’affectation dans le code appelant qui modifie cette variable.

Un résultat peut aussi être stocké ailleurs. Si triple(int n) multiplie sa variable locale n par 3 et la renvoie, alors int a = 4; int b = triple(a); laisse a égal à 4 et donne à b la valeur 12. L’affichage de a + " " + b produit « 4 12 ».

Applique la même règle aux références String

Une variable String contient une référence à un objet String. Java copie cette référence dans un paramètre String :

public static void exclaim(String text) {
    text = text + "!";
}

Si word dans le code appelant fait référence à « hi », après exclaim(word);, word fait toujours référence à « hi ». La concaténation crée un nouvel objet String et l’affectation ne modifie que l’objet auquel le paramètre fait référence. Le contenu existant d’une chaîne String ne peut pas être modifié.

Pour conserver le nouveau texte, renvoie text + "!" depuis une méthode String telle que exclaimed, puis écris word = exclaimed(word);.

Pour les objets mutables, comme les listes, une référence copiée peut toujours désigner le même objet. Une méthode peut modifier le contenu de cet objet par l’intermédiaire de la référence copiée. Réaffecter le paramètre ne peut toujours pas faire en sorte que la variable du code appelant fasse référence à un autre objet. La règle de la référence copiée et celle du nombre copié relèvent toutes deux du passage par valeur.

Tu peux réaffecter un paramètre, mais une variable locale distincte comme result peut rendre un calcul plus long plus facile à lire : elle conserve l’entrée initiale tout en montrant quelle valeur sera renvoyée.

La pile d’appels enregistre les appels qui ont commencé mais ne sont pas encore terminés. Chaque appel reçoit un cadre de pile contenant ses paramètres, ses variables locales et l’endroit où le code appelant reprendra.

Empile un cadre, termine l’appel, puis retire le cadre

La pile fonctionne selon le principe dernier entré, premier sorti. L’appel le plus récent est au sommet et s’exécute pendant que le code appelant attend en dessous. Lorsqu’il se termine, Java retire son cadre et reprend l’exécution du code appelant.

public static void main(String[] args) {
    int total = totalSeconds(2, 30);
    System.out.println(total);
}

public static int totalSeconds(int minutes, int seconds) {
    int fromMinutes = toSeconds(minutes);
    return fromMinutes + seconds;
}

public static int toSeconds(int minutes) {
    return minutes * 60;
}

Suis le travail inachevé :

1. main démarre et appelle totalSeconds(2, 30). Son affectation à total doit attendre.
2. Le nouveau cadre contient minutes = 2 et seconds = 30. Il appelle toSeconds(minutes) et attend la valeur de fromMinutes.
3. toSeconds reçoit son propre minutes = 2. Elle renvoie 120 et son cadre est retiré.
4. totalSeconds stocke fromMinutes = 120, ajoute 30 et renvoie 150. Son cadre est retiré.
5. main stocke total = 150 et affiche 150.

Au point le plus profond, les cadres sont, de bas en haut, main, totalSeconds et toSeconds. Les deux méthodes auxiliaires ont un paramètre nommé minutes, mais ces paramètres occupent des cadres différents. Les variables locales du code appelant en attente ne deviennent pas visibles pour la méthode située au-dessus.

Un appel ultérieur reçoit un nouveau cadre. Un compteur local ne conserve pas sa valeur précédente une fois son appel terminé ; c’est la valeur de retour qui peut transmettre un résultat au code appelant.

Lis une trace de pile en partant de l’erreur

Une exception non prise en charge affiche une trace de pile qui montre où l’erreur s’est produite et quels appels y ont conduit. Voici un fichier complet :

public class Main {
    public static void main(String[] args) {
        report(300, 0);
    }

    public static void report(int meters, int minutes) {
        int speed = perMinute(meters, minutes);
        System.out.println(speed + " m per minute");
    }

    public static int perMinute(int meters, int minutes) {
        return meters / minutes;
    }
}

La première ligne de sortie est Exception in thread "main" java.lang.ArithmeticException: / by zero. Les cadres situés en dessous sont :

at Main.perMinute(Main.java:12)
at Main.report(Main.java:7)
at Main.main(Main.java:3)

Le cadre supérieur indique la division entière par zéro. Les deux suivants situent les appels qui y ont conduit. Les numéros de ligne correspondent à cette disposition précise du fichier ; ajouter une ligne les modifie.

L’espace de la pile est limité. Une chaîne qui continue d’ajouter des appels sans les laisser se terminer peut provoquer une StackOverflowError. La vue de la pile d’un débogueur te permet d’examiner cette même chaîne pendant une pause à un point d’arrêt, y compris les variables distinctes de chaque appel en attente.

La surcharge consiste à donner le même nom à des méthodes dont les listes de paramètres sont différentes. Elle est utile lorsque les méthodes accomplissent la même tâche pour des entrées de nombres ou de types différents.

Compare les signatures

Pour ces méthodes, une signature se compose du nom et des types des paramètres dans leur ordre. Le nombre de paramètres découle de cette liste.

public static int max(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

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

public static double max(double a, double b) {
    if (a > b) {
        return a;
    }
    return b;
}

Les signatures sont max(int, int), max(int, int, int) et max(double, double). max(3, 9) utilise la première et renvoie 9. max(3, 9, 5) appelle la deuxième : l’appel interne à deux int renvoie 9, puis l’appel externe à deux int compare 9 et 5 et renvoie aussi 9. max(2.5, 1.0) utilise la version double et renvoie 2.5.

Identifie les changements qui ne comptent pas

Changer uniquement le type de retour ne crée pas une surcharge. Ces en-têtes sont en conflit :

public static int area(int w, int h)
public static double area(int w, int h)

Les deux ont la signature area(int, int). Java rejette la déclaration en double. Renommer les paramètres en width et height laisse aussi la même signature : le code appelant fournit les valeurs par position, pas par nom de paramètre.

L’ordre de types différents compte. describe(String s, int n) et describe(int n, String s) ont des signatures distinctes. Elles compilent ensemble, mais le code appelant doit retenir un ordre facile à confondre ; utilise donc une telle paire seulement si elle est utile à la conception.

Laisse une surcharge plus courte fournir une valeur par défaut

Java ne fournit pas de valeurs de paramètres par défaut dans les déclarations de méthodes. Une surcharge plus courte peut appeler une version plus longue avec un argument fixe :

public static void printLine(int length, char symbol) {
    for (int i = 0; i < length; i++) {
        System.out.print(symbol);
    }
    System.out.println();
}

public static void printLine(int length) {
    printLine(length, '-');
}

printLine(5, '*'); affiche *****. printLine(4); entre dans la méthode plus courte, qui appelle la plus longue avec 4 et '-', ce qui affiche ----. La boucle ne figure qu’à un seul endroit : les modifications de la tâche d’affichage s’appliquent donc aux deux formes.

La bibliothèque Java utilise aussi des surcharges. System.out.println accepte un int, un double, un char, un boolean ou un String grâce à différentes versions. Math.abs et Math.max proposent des versions pour int, long, float et double.

Garde un seul sens pour le nom partagé. Afficher un reçu et afficher une étiquette sont des tâches différentes ; des noms clairs comme printReceipt et printLabel indiquent au code appelant quelle tâche sera accomplie.

Le compilateur choisit une surcharge à partir du nombre et des types des arguments. Détermine ce choix avant d’examiner comment la valeur renvoyée sera utilisée.

Commence par les correspondances exactes

Supposons qu’une classe définisse show(int x) et show(double x). show(5) utilise la version int car le littéral 5 est un int. show(5.0) utilise la version double. Une valeur entière écrite 5.0 reste une expression de type double.

Pour un appel avec plusieurs arguments, compare le type à chaque position. Une méthode candidate qui ne possède pas le bon nombre de paramètres ne peut pas convenir.

Accepte les conversions élargissantes si nécessaire

Si seule show(double x) existe, show(5) est valide : le int est converti par élargissement en 5.0. Les chemins de conversion élargissante des types primitifs comprennent :

byte → short → int → long → float → double
char → int → long → float → double

Avec show(long x) et show(double x), un argument int sélectionne long. C’est le type de paramètre compatible le plus spécifique : un long peut subir une conversion élargissante en double, tandis qu’un double ne peut pas subir une telle conversion en sens inverse vers long.

Une conversion élargissante est une conversion numérique autorisée ; elle ne garantit pas que chacune de ces conversions conserve tous les chiffres. En particulier, la conversion d’un long suffisamment grand en double peut arrondir sa valeur. La conversion de int en double utilisée dans les exemples précédents conserve exactement toutes les valeurs int.

Un char possède aussi une valeur numérique. Avec letter(int code) et letter(String text), letter('A') appelle la version int avec 65. Un caractère ne devient pas un String pour correspondre à un paramètre. Les guillemets doubles dans "A" produiraient en revanche un argument String.

Refuse les conversions réductrices implicites

Avec la seule version show(int x), show(5.0) échoue. Java n’effectue pas de conversion réductrice d’un argument double simplement parce que sa valeur est entière. show((int) 5.0) transmet un int après un transtypage explicite.

De même, des versions de max pour deux et trois int ne peuvent pas accepter max(1). Aucune méthode candidate n’a le nombre de paramètres requis : le compilateur indique donc « no suitable method found ». Compare la liste des méthodes candidates aux arguments fournis.

Distingue le choix de la surcharge de la conversion du résultat

Considère int twice(int n) et double twice(double x). Dans double d = twice(3);, l’argument sélectionne la surcharge int. Cet appel renvoie 6, puis l’affectation effectue une conversion élargissante en 6.0. La variable de destination d ne sélectionne pas la surcharge double.

Reconnais un appel ambigu

public static void combine(int a, double b) { }
public static void combine(double a, int b) { }

combine(1, 2) convient à la première après une conversion élargissante de son deuxième argument et à la seconde après une conversion élargissante de son premier argument. Aucune signature n’est plus spécifique sur les deux positions. Java indique « reference to combine is ambiguous » ; il ne choisit pas la définition écrite en premier.

combine(1, 2.0) ne convient qu’à (int, double), car l’autre signature nécessiterait une conversion réductrice de 2.0. Un type d’argument clair ou un meilleur ensemble de surcharges supprime l’ambiguïté.

La décomposition consiste à diviser un problème en tâches plus petites et à résoudre chaque tâche dans sa propre méthode. Choisis des tâches dont les noms aident à lire le plan du programme.

Sépare les calculs des entrées-sorties

Un programme sur une sortie à vélo doit calculer une vitesse et produire un compte rendu. Ces deux tâches utilisent les mêmes données, mais ont des rôles différents :

public static double kilometersPerHour(double km, double hours) {
    return km / hours;
}

public static void printRideReport(double speed) {
    System.out.println("Speed: " + speed + " km/h");
}

Pour une sortie de 150 km en 2 heures, le calcul renvoie 75.0. La méthode de compte rendu reçoit cette valeur et l’affiche. Le code appelant relie les étapes :

double speed = kilometersPerHour(150, 2);
printRideReport(speed);

La méthode de calcul ne lit aucune saisie au clavier et n’affiche aucun compte rendu. Un autre programme peut l’utiliser pour comparer des sorties ou stocker des vitesses sans modifier son corps. Pour la tester, appelle-la avec des entrées connues et compare le nombre renvoyé au résultat attendu.

Reconnais une méthode qui accomplit trop de tâches

Un nom comme readAndCheckAndPrint suggère plusieurs actions. D’autres indices comprennent des sections délimitées par des commentaires, un corps plus long qu’un écran et des groupes de variables qui servent à des tâches sans rapport. Ce sont des raisons d’examiner la méthode, pas des limites mécaniques sur le nombre de lignes qu’elle peut contenir.

Sépare les tâches à un endroit qui a un sens. Le code d’entrée peut obtenir une valeur, une méthode auxiliaire booléenne peut la vérifier, une méthode de calcul peut renvoyer un résultat et une méthode de compte rendu peut l’afficher. main se lit alors comme une courte description de la façon dont ces tâches s’enchaînent.

Les méthodes ciblées sont plus faciles à lire séparément, à réutiliser et à tester. Si le format d’un compte rendu change, modifie la méthode de compte rendu. Si un calcul est erroné, teste ce calcul sans avoir à saisir toutes les données d’une session.

Laisse l’en-tête expliquer la circulation des données

Dans kilometersPerHour(double km, double hours), le nom indique le résultat, les noms des paramètres indiquent les grandeurs et le type de retour double indique la nature de la réponse. Un court commentaire Javadoc peut préciser le sens des entrées et du résultat :

/**
 * Calculates a ride's average speed.
 * @param km distance in kilometers
 * @param hours elapsed time in hours, greater than zero
 * @return speed in kilometers per hour
 */

Place ce commentaire directement au-dessus de l’en-tête de la méthode. Un commentaire utile ajoute des informations comme les unités ou une exigence sur les entrées ; il n’a pas besoin de raconter chaque ligne du corps.

Une méthode auxiliaire nécessaire uniquement à sa propre classe peut être private static. private empêche les autres classes de l’appeler, tandis que le code de la même classe peut toujours l’utiliser. public static rend la méthode auxiliaire accessible aux autres classes.

Encapsuler chaque instruction évidente dans sa propre méthode peut aussi masquer le plan. Garde une méthode lorsque son nom représente une étape utile ou un calcul réutilisable. Une chaîne de méthodes auxiliaires qui se contentent de transmettre le même appel ajoute des endroits à examiner sans mieux expliquer la tâche.

Le code dupliqué répète la même tâche à plusieurs endroits. Lorsque seules les valeurs d’entrée diffèrent, une méthode paramétrée peut rassembler le travail commun.

Repère le calcul commun

Supposons qu’un programme additionne les nombres de 1 à 10, puis de 1 à 50 :

int total1 = 0;
for (int i = 1; i <= 10; i++) {
    total1 += i;
}
System.out.println("Sum 1 to 10: " + total1);
int total2 = 0;
for (int i = 1; i <= 50; i++) {
    total2 += i;
}
System.out.println("Sum 1 to 50: " + total2);

Les deux boucles commencent à 1, ajoutent des valeurs à une somme et s’arrêtent à une borne supérieure. Seule cette borne change. Un paramètre n peut la transmettre à un calcul commun.

Extrais la méthode

public static int sumUpTo(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++) {
        total += i;
    }
    return total;
}

n est l’entrée qui varie. total et i sont des variables de travail qui appartiennent à la méthode auxiliaire. Le code appelant a besoin de la somme finale : la méthode auxiliaire renvoie donc un int.

Remplace les deux sections répétées :

System.out.println("Sum 1 to 10: " + sumUpTo(10));
System.out.println("Sum 1 to 50: " + sumUpTo(50));

sumUpTo(10) renvoie 55 et sumUpTo(50) renvoie 1275. Les lignes affichées sont « Sum 1 to 10: 55 » et « Sum 1 to 50: 1275 », comme avant. Les descriptions restent dans le code appelant ; la boucle effectue uniquement le calcul.

Vérifie l’extraction dans un ordre précis

1. Repère les instructions qui effectuent la tâche répétée.
2. Identifie chaque valeur qui diffère entre les copies.
3. Transforme ces valeurs en paramètres de types adaptés et renvoie tout résultat nécessaire à l’extérieur.
4. Remplace chaque copie par un appel utilisant ses entrées initiales.
5. Exécute le programme avec les mêmes entrées avant et après, puis compare son comportement.

Modifier la structure du code tout en préservant son comportement est une refactorisation. Si une copie initiale reste en place, une correction ultérieure devra toujours être faite à deux endroits. Déplacer une instruction d’affichage dans une boucle ou modifier une borne de boucle change le comportement, même si le code est désormais plus court.

Lorsque deux différences sont de types différents, utilise des paramètres correspondants. Répéter différents textes un nombre variable de fois suggère printRepeated(String text, int times) ; le mot est un String et le nombre de répétitions est un int.

Du code d’apparence similaire n’accomplit pas toujours la même tâche. Un paramètre booléen qui fait passer une méthode d’un calcul sans rapport à un autre peut rendre ses appels difficiles à interpréter. Donne des noms distincts aux tâches distinctes. Extrais l’opération répétée uniquement lorsque faire varier ses entrées préserve un sens clair et unique.

La conception descendante part de la tâche entière et l’affine en appels de méthodes plus petits. Décide de ce dont chaque appel a besoin et de ce qu’il renvoie avant de remplir tous les détails.

Planifie les étapes et les en-têtes

Un programme de suivi de l’exercice hebdomadaire lit 7 durées quotidiennes, en calcule le total et affiche un compte rendu. Ses méthodes auxiliaires peuvent être prévues ainsi :

• readMinutes(Scanner scanner, int day) renvoie le nombre de minutes valide pour une journée.
• isValidMinutes(int minutes) indique si l’entrée est comprise entre 0 et 1 440.
• formatDuration(int minutes) renvoie un texte avec les heures entières et les minutes restantes.
• averagePerDay(int total, int days) renvoie une moyenne de type double.
• printSummary(int totalMinutes, int days) affiche le compte rendu.

Le même Scanner est transmis à chaque appel de lecture. Une méthode auxiliaire comme isValidMinutes n’a pas besoin de lire elle-même les données en entrée.

Utilise des bouchons pendant la construction

Un bouchon possède son en-tête définitif, mais un corps minimal temporaire, comme return 0;. Il permet au programme de compiler avant qu’une méthode auxiliaire soit implémentée. Remplace un bouchon, compile et vérifie cette méthode avant de remplacer le suivant. Un bouchon qui compile reste un travail inachevé ; sa réponse fixe ne peut pas vérifier un véritable calcul.

Voici le programme terminé :

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int total = 0;
        for (int day = 1; day <= 7; day++) {
            total += readMinutes(scanner, day);
        }
        printSummary(total, 7);
    }

    public static int readMinutes(Scanner scanner, int day) {
        System.out.println("Minutes for day " + day + ":");
        int minutes = scanner.nextInt();
        while (!isValidMinutes(minutes)) {
            System.out.println("Enter minutes from 0 to 1440:");
            minutes = scanner.nextInt();
        }
        return minutes;
    }

    public static boolean isValidMinutes(int minutes) {
        return minutes >= 0 && minutes <= 1440;
    }

    public static String formatDuration(int minutes) {
        return minutes / 60 + " h " + minutes % 60 + " min";
    }

    public static double averagePerDay(int total, int days) {
        return (double) total / days;
    }

    public static void printSummary(int totalMinutes, int days) {
        System.out.println("Total: " + formatDuration(totalMinutes));
        System.out.println("Daily average: "
            + averagePerDay(totalMinutes, days) + " min");
        if (totalMinutes >= 150) {
            System.out.println("Weekly goal reached");
        }
    }
}

Pour une entrée entière, readMinutes répète sa vérification de l’intervalle jusqu’à ce que le nombre soit valide. Avec les entrées quotidiennes 30, 45, 0, 60, 90, 45 et 45, le total est de 315. Le formatage donne « 5 h 15 min », la moyenne est de 45.0 minutes et le programme indique que son objectif hebdomadaire de 150 minutes est atteint.

Vérifie les petites méthodes et leurs bornes

Appelle chaque méthode de calcul avec des résultats connus. formatDuration(0) doit donner « 0 h 0 min », 59 donne « 0 h 59 min », 60 donne « 1 h 0 min » et 135 donne « 2 h 15 min ». Les entrées juste en dessous de 60 et égales à cette valeur vérifient le passage des minutes à une heure entière.

Pour isValidMinutes, teste -1, 0, 1440 et 1441. Les résultats attendus sont false, true, true et false. Afficher côte à côte les valeurs attendues et obtenues rend une erreur visible. JUnit automatise ce type de vérification.

Le développement ascendant commence par l’écriture et le test de petites méthodes auxiliaires, puis les réunit en étapes plus grandes. Tu peux planifier de manière descendante et construire de manière ascendante : établis d’abord la circulation des données, vérifie que les petits calculs fonctionnent, puis teste le programme une fois ses éléments reliés.