Le Debug dans IntelliJ IDEA

1. Bug

Les programmeurs ont leur propre jargon. Et le premier mot avec lequel vous vous familiariserez vraiment sera le bug (de l'anglais bug — insecte/punaise). Ce mot désigne une erreur dans un programme qui fait qu'il ne se comporte pas comme prévu, plante ou renvoie un résultat étrange.

Si un programme fonctionne bizarrement, mais que le développeur assure que c'était voulu, on dit généralement : « Ce n'est pas un bug, c'est une feature ». Internet est rempli de mèmes à ce sujet.

Note historique

La légende raconte qu'en septembre 1947, des scientifiques de Harvard testaient l'ordinateur Mark II. Il dysfonctionnait. Après avoir vérifié tous les contacts, ils ont trouvé une véritable phalène coincée entre les relais. L'insecte a été scotché dans le journal de bord avec la légende « First actual case of bug being found » (Premier cas réel de découverte d'un bug).

Depuis lors, le processus de recherche et de correction des erreurs est appelé debug ou débogage.

---

2. Debug Mode

Pour trouver une erreur, les développeurs utilisent le Debugger (débogueur). C'est un outil spécial intégré à IntelliJ IDEA qui permet de mettre l'exécution du programme en pause et de regarder « sous le capot ».

Intellij IDEA peut exécuter votre programme dans deux modes :

En mode debug, vous pouvez exécuter le programme ligne par ligne, en observant comment les valeurs des variables changent.

3. Points d'arrêt (Breakpoints)

Pour que le Debugger sache où s'arrêter, vous devez placer un Break Point (point d'arrêt). Sans cela, le programme s'exécutera simplement jusqu'à la fin, comme d'habitude.

Entraînons-nous sur un exemple concret. Nous avons extrait la logique de multiplication dans une méthode distincte pour montrer toute la puissance du débogueur. Copiez ce code dans IDEA :

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int result = calculateMultiply(i);  // <--- Nous voulons nous arrêter ici
            sum += result;
            System.out.println("Step: " + i + ", Result: " + result + ", Sum: " + sum);
        }
        System.out.println("Final Sum: " + sum);
    }

    public static int calculateMultiply(int number) {
        return number * 2;
    }
}

Objectif : Nous voulons voir comment les variables changent à l'intérieur de la boucle et jeter un coup d'œil à l'intérieur de notre méthode.

Action : Cliquez avec la souris dans la fine bande grise à gauche de la ligne int result = calculateMultiply(i);. Un cercle rouge apparaîtra.

Maintenant, lancez le programme via le bouton Debug (l'icône en forme d'insecte). Le programme va démarrer et se « figer » instantanément avant d'exécuter cette ligne.

4. Contrôles : F8, F7, F9

Lorsque le programme est en pause, vous disposez d'un panneau de contrôle en haut de la fenêtre du Debugger.

F8 — Step Over (Passer par-dessus)

Appuyez sur F8. Le programme exécutera la ligne actuelle (appellera la méthode, obtiendra le résultat) et passera à la suivante sum += result;.

Appuyez à nouveau sur F8. Le programme additionnera les nombres. Vous verrez comment les valeurs des variables ont changé.

Appuyez encore sur F8. Vous verrez la sortie dans la console.

C'est la méthode principale pour se déplacer : ligne par ligne, sans entrer dans les détails internes des méthodes.

F9 — Resume Program (Reprendre l'exécution)

Nous avons une boucle de 1 à 5. Appuyer sur F8 cinq fois pour faire un tour de boucle, c'est long. Et si la boucle avait 1000 itérations ?

Appuyez sur F9. Le programme va « se débloquer », exécuter tout le reste du code de l'itération actuelle, passer au deuxième tour et... s'arrêter à nouveau sur le Breakpoint.

Ainsi, avec F9, vous pouvez faire défiler rapidement les boucles : un appui = une itération.

F7 — Step Into (Entrer dedans)

Si le code rencontre un appel à votre méthode (dans notre cas calculateMultiply(i)), et que vous appuyez sur F8, le Debugger l'exécutera simplement et passera à la suite. Mais si vous voulez voir comment le code fonctionne à l'intérieur de cette méthode — appuyez sur F7.

Essayez d'appuyer sur F7 lorsque le programme s'arrête sur la ligne int result = calculateMultiply(i);. Le Debugger vous transportera à l'intérieur de la méthode calculateMultiply, et vous verrez comment la valeur est passée au paramètre number.

Shift + F8 — Step Out (Ressortir)

Que faire si vous avez appuyé sur F7 par erreur sur la ligne System.out.println(...) et que vous vous retrouvez dans les méandres du code système Java ? Lire des milliers de lignes de code qui ne vous appartiennent pas est ennuyeux et incompréhensible.

Appuyez sur Shift + F8. Le programme exécutera rapidement tout ce qui reste dans la méthode actuelle et vous ramènera là d'où vous venez (dans votre méthode main).

5. Où voir les valeurs ?

Revenons à notre exemple avec la boucle.

Méthode 1 : Inline Debugging

Regardez directement dans l'éditeur de code. À droite des lignes, IDEA écrit les valeurs actuelles en gris.

Méthode 2 : Le panneau Variables

En bas de la fenêtre du Debugger se trouve l'onglet Variables. Il affiche toutes les variables actuelles.

Précision importante pour Java : Les types primitifs (comme int) affichent leur valeur immédiatement. Mais les objets et les tableaux (comme String[]) stockent beaucoup de données en eux. Pour voir leur contenu, vous devez cliquer sur la petite flèche à gauche de la variable pour « dérouler » l'objet.

Méthode 3 : Le panneau Frames (Pile d'appels)

À gauche des variables se trouve une liste appelée Frames. Elle montre à quelle étape se trouve actuellement le programme.

Par exemple, l'inscription main:6, Main signifie :

• Vous êtes dans la méthode main de la classe Main.
• Vous êtes arrêté à la ligne numéro 6.

C'est votre adresse exacte dans le code. Si vous plongez dans une autre méthode (en appuyant sur F7 sur calculateMultiply), une nouvelle entrée calculateMultiply:13, Main apparaîtra en haut de cette liste, indiquant que la nouvelle méthode a été appelée depuis la précédente.

6. Evaluate Expression (Évaluer une expression)

Parfois, regarder simplement les variables ne suffit pas. Vous voulez demander : « Et que se passerait-il si... »

Appuyez sur Alt + F8 (Windows/Linux) ou Option + F8 (macOS). La fenêtre « Evaluate » s'ouvrira. Vous pouvez également taper des expressions directement dans la barre sous le panneau Variables.

Ici, vous pouvez écrire n'importe quel code en utilisant les variables actuelles. Par exemple, dans notre boucle, tapez :

sum + 100

Appuyez sur Enter et IDEA calculera le résultat sans modifier le vrai programme. C'est votre brouillon pour faire des expériences.

7. Conditional Breakpoints (Points d'arrêt conditionnels)

Imaginez que vous avez une boucle de 10 000 itérations, et que l'erreur ne se produit qu'à la 5000ème étape. Appuyer sur F9 cinq mille fois est une mauvaise idée.

Faites un clic droit sur le cercle rouge du Breakpoint. Une fenêtre pop-up apparaîtra. Dans le champ Condition, écrivez une condition en Java, par exemple : i == 5. Cliquez sur Done.

Maintenant, si vous lancez le Debugger, le programme ignorera les 4999 premiers tours et ne s'arrêtera que lorsque la condition deviendra true. Cela vous fera gagner des heures de travail !

8. Gérer tous les points d'arrêt

Parfois, les débutants placent tellement de Breakpoints dans différents fichiers du projet que le programme s'arrête ensuite constamment à des endroits inattendus. Chercher les cercles rouges manuellement dans tous les fichiers prend du temps.

Appuyez sur Ctrl + Shift + F8 (Windows/Linux) ou Cmd + Shift + F8 (macOS). La fenêtre Breakpoints s'ouvrira.

Ici, vous voyez la liste de tous les points d'arrêt de votre projet. Vous pouvez les décocher (les désactiver temporairement) ou les supprimer avec la touche Delete.

9. Résumé

Nous avons passé en revue l'arsenal principal du développeur Java pour la recherche d'erreurs. Le débogueur (Debugger) est ce qui transforme l'écriture de code de la « divination dans le marc de café » en un travail d'ingénierie précis.

La capacité à trouver rapidement la cause d'une erreur est une compétence qui est valorisée dans le développement commercial encore plus que la capacité à écrire du code rapidement. Entraînez-vous avec les points d'arrêt conditionnels et l'Evaluation, et aucun bug ne vous échappera.