Environnements de Développement Intégrés

Dans cette unité, nous discutons de l'intérêt d'utiliser un IDE pour le développement et illustrons comment les activités clés des développeurs sont gérées à l'aide d'IntelliJ IDEA (édition ultime).

Résumé de la conférence

Les IDE rassemblent les outils et interfaces pour les activités quotidiennes des développeurs de logiciels, depuis la coloration syntaxique, le formatage de code, l'auto-complétion de code, la navigation dans le code, le débogage, le contrôle de version graphique, jusqu'aux plugins personnalisés pour des besoins spécifiques au projet.

Deux commentaires :

Lors du premier lancement, votre IDE IntelliJ pourrait avoir une apparence légèrement différente de celle que vous voyez en cours.
Pas de panique, vous avez téléchargé la bonne version. Cependant, il existe deux interfaces : Moderne et Classique.
Tout le matériel du cours fait référence à la version Classique.
Pour basculer, choisissez Paramètres -> Apparence -> nouvelle interface utilisateur et désélectionnez la case à cocher.
J'utilise souvent des combinaisons de touches pour accéder rapidement aux menus de mon IDE.
Les combinaisons de touches sont fournies dans ce guide, cependant, elles sont spécifiques à MacOS.
Pas de panique, les touches Windows/Linux sont presque les mêmes.
Vous pouvez facilement consulter les combinaisons sur votre système en utilisant la feuille de triche : Aide -> Raccourcis Clavier PDF.

Au-delà de votre éditeur de texte standard

Il est tout à fait possible de coder même de grands projets logiciels avec un éditeur de texte de base. Cependant, les choses deviennent rapidement très peu pratiques. Par exemple, vous n'avez pas : de coloration syntaxique, de mise en forme automatique, de suggestions d'API, de navigation dans le code, ... et bien d'autres encore.

Et qu'en est-il de vim, n'est-ce pas un type d'IDE ?

Vim et emacs sont des éditeurs, écrits par des développeurs, pour des développeurs. Vous pouvez tout à fait les utiliser et configurer une longue liste de plugins pour obtenir quelque chose de semblable à un IDE. Cependant, vous pourriez passer plus de temps à configurer votre éditeur qu'à travailler sur votre projet. C'est acceptable pour les utilisateurs avancés, mais dans ce cours, nous allons nous en tenir à un IDE graphique.

Coloration syntaxique

Une caractéristique clé de tout IDE est la coloration syntaxique spécifique au langage.

Les programmes Java doivent être 100 % syntaxiquement corrects, sinon le compilateur rejettera votre code.
- Il est trop facile de faire une petite erreur de syntaxe, votre programme pourrait par exemple être rejeté simplement parce qu'il vous manque un point-virgule :

Repérez l'erreur de syntaxe : System.out.printl("Hello, World!")

En réalité, il y en a 2 :
- L'appel de méthode correct est print ou println.
- Manque de point-virgule après l'instruction.

Même le développeur le plus expérimenté fait des erreurs de syntaxe.
C'est pourquoi nous utilisons des outils d'assistance :
- Les IDE ont une analyse AST automatique pour mettre en évidence toutes les erreurs de syntaxe, pendant que vous tapez.
- Un marqueur rouge sur la barre de défilement indique une erreur de syntaxe.
- Survolez le marqueur ou la ligne pour obtenir une explication de l'erreur, par exemple : "Point-virgule manquant après l'instruction à la ligne 42."
- Dans certains cas, l'IDE propose même une solution rapide que vous pouvez appliquer d'un simple clic.

Mise en forme automatique du code

La mise en forme va au-delà de la correction syntaxique.

Du point de vue du compilateur, les deux extraits de code ci-dessous sont identiques, ils partagent la même structure AST :

Code non formaté :

package ca.uqam.info;public class App{public static void main(String[] args){String uni = "UQAM";System.out.println( "Hello, "+uni+"!" );}}

Code formaté :

package ca.uqam.info;

public class App {
  public static void main(String[] args) {
      String uni = "UQAM";
      System.out.println("Hello, " + uni + "!");
  }
}

La plupart des humains conviendraient que le deuxième échantillon est plus lisible.
IntelliJ peut auto-formater le code pour une meilleure lisibilité
- Mac OS : Commande (⌘) + Option (⌥) + L
- Linux / Windows : Ctrl + Alt + L

Profils de mise en forme

Il existe une infinité de façons de formater le code.

Exemples :
- Certains développeurs préfèrent tabulations plutôt que espaces
- Certains développeurs veulent que toutes les { soient sur la ligne suivante
- Certains développeurs veulent que les méthodes soient indentées de seulement 2 espaces
- ...
Il est important que tous les développeurs utilisent les mêmes paramètres de mise en forme
- Le formatage du code deviendra bientôt un critère de notation.

Checkstyle comme profil de mise en forme

Nous utiliserons un profil de mise en forme qui est à la fois compatible avec Checkstyle, un plugin de linter de code statique. (Il y aura une conférence dédiée sur les linters)

Installez le plugin Checkstyle
1. Allez dans Paramètres -> Plugins -> Marketplace
2. Tapez "Checkstyle"
3. Activez "plugin Checkstyle"
Activez le profil Google Checkstyle
1. Téléchargez le fichier de configuration XML de Google Checkstyle
2. Allez dans Paramètres -> Éditeur -> Style de Code -> Java
3. Cliquez sur l'icône de l'engrenage
4. Sélectionnez le fichier google_checks.xml

Une fois le profil chargé, tout code que vous formatez respecte automatiquement les conventions de style de code de Google.

Quel est l'effet sur les commits git lorsque différents profils de mise en forme sont utilisés ?

Pratiquement chaque ligne de votre code change à chaque commit. Il sera presque impossible de distinguer les changements de code des changements de mise en forme. La fusion du code sera fastidieuse et chronophage.

Contrairement à un éditeur de texte standard, l'IDE a une notion de la façon dont le code est connecté.

Cela vous permet une navigation pratique, par exemple, pour suivre les graphes d'appels.
Pour suivre une méthode appelée jusqu'à sa définition, maintenez Commande (⌘) et cliquez sur l'appel de méthode.

Inspecter la structure du fichier

Que vous écriviez du code Java ou du code Markdown, il y a toujours une sorte de structure.

Bien sûr, vous pouvez faire défiler jusqu'à ce que vous trouviez ce que vous cherchez
Mais la combinaison de structure de fichier est plus rapide : Commande (⌘) + F12 (+ Fn sur les ordinateurs portables)

Recherche structurée

Imaginez que vous savez qu'un champ stocke une information spécifique, mais vous ne vous souvenez pas dans quelle classe il se trouve.
IntelliJ vous permet de rechercher facilement des éléments de code spécifiques, par exemple, des champs de toutes les classes.
- Utilisez : Shift + Commande (⌘) + A => actions
- Ensuite, tapez : Structure
Vous verrez un modèle de recherche pour tous les champs de toutes les classes.
```
class $Class$ {
  $FieldType$ $Field$ = $Init$;
}
```
* Mais vous pouvez facilement délimiter la recherche, par exemple, pour restreindre la recherche aux champs final :

class $Class$ {
  final $FieldType$ $Field$ = $Init$;
}

Filtres

Souvent, le nombre de résultats est plus que ce que vous pouvez traiter. Mais vous pouvez restreindre la sortie exactement à ce que vous recherchez.

Par exemple, vous pourriez chercher une instruction de ligne d'impression, mais elle pourrait se trouver n'importe où dans le code.
Pour ce faire, vous pouvez commencer par rechercher tous les appels de méthode (qui incluront les impressions).

  $Instance$.$MethodCall$($Parameter$)

Ensuite, vous pouvez appliquer un filtre (symbole de filtre à droite) pour réduire l'ensemble des résultats à des critères spécifiques.
- Le filtre peut s'appliquer au type de paramètre ou au nom de la méthode elle-même. Il suffit de cliquer sur l'élément pour lequel vous souhaitez appliquer le filtre, avant d'ajouter le filtre avec l'icône +.
Exemple :
- Cliquez sur MethodCall et ajoutez un filtre de texte : print. Cela révèle toutes les méthodes print.
- Pour correspondre également à println, utilisez une expression régulière, c'est-à-dire print.*.
Maintenant, vous voyez toutes les instructions d'impression, qu'il s'agisse de print, printf ou println.

Parcourez les modèles de recherches et filtres fournis

La syntaxe des instructions de recherche est parfois un peu difficile à comprendre, mais IntelliJ propose des modèles pour la plupart des recherches courantes. Ne vous embêtez pas à réinventer la roue lorsque vous pouvez simplement choisir un modèle de recherche prêt à l'emploi.

Avancé : Vous pouvez également remplacer de manière structurée, par exemple, pour remplacer toutes les instructions System.out.println consommant une chaîne par un appel au logger.

Refactorisation

Renommage avancé

Le renommage manuel est assez risqué :
- Vous devez renommer toutes les occurrences de variables / méthodes.
- Si vous oubliez une seule occurrence, votre code ne compilera plus.
- Si vous renommez une variable, vous devez également...
  - adapter les getters et setters.
  - adapter la documentation JavaDoc.
- Si vous renommez des packages, de nombreux fichiers peuvent être affectés et nécessiteront un déplacement sur le disque.
Votre IDE peut vous aider dans cette tâche, car il effectue une analyse statique du code et sait comment les identifiants sont connectés à travers votre code (et vos fichiers).
- Sélectionnez l'identifiant à renommer.
- Accédez à la fonctionnalité de renommage avec Shift + F6 (peut nécessiter la touche Fn sur les ordinateurs portables pour accéder à F6).
- Tapez un nouveau nom.
- Appuyez sur Entrée.

Attention au renommage de package lorsqu'un VCS est impliqué

Git pourrait ne pas comprendre que les fichiers viennent d'être renommés et déplacés, et les futures fusions pourraient devenir compliquées. Pour le renommage de package, il est toujours bon d'utiliser la commande git mv ... Commande (⌘)s.

Changement de signatures

Semblable au renommage, il s'agit de modifier la signature d'une méthode, par exemple, en ajoutant un paramètre d'entrée.

Vous devez modifier de manière cohérente tous les appels de méthode, sinon votre code ne compilera pas.
IntelliJ peut encore une fois vous aider dans cette tâche :
- Changez uniquement la définition de la signature (votre code a maintenant des erreurs).
- Cliquez sur l'annotation @R dans le panneau de gauche.
- Ajoutez une valeur par défaut pour le nouveau paramètre, dans tous les appels de méthode existants.
Alternativement, vous pouvez utiliser la boîte de dialogue de refactorisation de signature de méthode dédiée avec Commande (⌘) + F6 (et Fn sur les ordinateurs portables). La boîte de dialogue dispose de fonctionnalités supplémentaires, par exemple :
- Changer l'ordre des paramètres.
- Surcharge de méthode.

Extraire une méthode

Souvent, vous avez quelques lignes de code qui effectuent parfaitement une tâche, mais vous aimeriez les rendre accessibles en tant que méthode dédiée (et cette méthode étant simplement appelée là où le code se trouve actuellement).
- Exemple :

    /**
 * Creates an interleaved true, false, true, false... array and prints the outcome.
 * @param length as the total amount of values to be placed in the result array.
 */
void foo(int length) {

  // initialize a new all-false boolean array
  boolean[] myArray = new boolean[length];

  // convert every value at an even position to true:
  for (int i = 0; i < myArray.length; i++) {
    if (i % 2 == 0) {
      myArray[i] = true;
    }
  }

  // print the array content
  for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
  }
}

Pourrait être refactorisé en :

      /**
 * Creates an interleaved true, false, true, false... array and prints the outcome.
 * @param length as the total amount of values to be placed in the result array.
 */
void foo(int length) {

  // initialize a new all-false boolean array
  boolean[] myArray = new boolean[length];

  setEveryEvenPositionTrue(myArray);

  // print the array content
  for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
  }
}

/**
 * Sets every even position of a provided array to true.
 * @param myArray the array to be modified.
 */
private static void setEveryEvenPositionTrue(boolean[] myArray) {
  // convert every value at an even position to true:
  for (int i = 0; i < myArray.length; i++) {
    if (i % 2 == 0) {
      myArray[i] = true;
    }
  }
}

Vous pourriez modifier manuellement le code pour créer une nouvelle méthode, copier-coller les lignes sélectionnées, puis insérer un appel de méthode à l'emplacement d'origine...
Ou vous pouvez simplement utiliser un raccourci IntelliJ : Option (⌥) + Command (⌘) + M

Il existe également une opération inverse : Méthode inline. L'inverse remplace un appel à une méthode par le code de la méthode. Sélectionnez l'appel de méthode et appuyez sur Option (⌥) + Command (⌘) + N.

Valeurs magiques en constantes

L'utilisation de valeurs magiques en dur est considérée comme une mauvaise pratique, même si la variable n'apparaît qu'une seule fois.
Sélectionnez la variable et appuyez sur : Option (⌥) + Command (⌘) + C

Champs en paramètres de méthode

Souvent, vous avez des valeurs dans une méthode qui devraient être injectées de l'extérieur.
Vous pouvez marquer les paramètres et appuyer sur Option (⌥) + Command (⌘) + P
Exemple :

      /**
 * Creates an array and calls toto on it.
 * @param length as the size of the array to create before passing it to toto.
 */
void foo(int length) {

  // initialize a new all-false boolean array
  boolean[] myArray = new boolean[length];
  toto(myArray);
}
      }

Se convertit en :

      /**
 * Receives an array and calls toto on it.
 * @param myArray as the array to call toto on.
 */
void foo(boolean[] myArray) {
  toto(myArray);
}

Expression en variable

Les expressions plus longues peuvent être difficiles à comprendre :

    if(i< 3984574&&i%2==true||i ==42){
    ...
    }

Vous pouvez remplacer des parties des expressions par des variables nommées avec Option (⌥) + Command (⌘) + v :

        boolean iSmallerMaxValue = i < 3984574;
        int correctAnswer = 42;
        boolean iIsEven = i % 2 == true;
        if(iSmallerMaxValue && iIsEven || i ==correctAnswer){
        ...
        }

Complétion de code

Complétion de base

Si vous êtes sur le point d'écrire une fonction qui retourne un boolean, IntelliJ peut faire correspondre la chaîne return t... et proposer vos options (⌥)(⌥) :

IntelliJ peut auto-formater le code pour une meilleure lisibilité

Mac OS : Contrôle (⌃) + Espace
Linux / Windows : Contrôle (⌃) + Espace

Complétion d'appel de méthode

Vous pouvez également utiliser l'IDE pour parcourir les appels de méthode disponibles, par exemple, lorsque vous vous êtes préparé à un appel de méthode avec :

String myString = "foo";
foo. // IntelliJ will pop-up available String methods on "." typed.

Bien sûr, vous pouvez toujours simplement lire l'API officielle, mais une recherche rapide des méthodes disponibles est généralement plus rapide et réduit les changements de contexte.

Modèles en direct

Souvent, vous souhaitez créer une construction assez standard, qui ressemble toujours à la même chose, comme une déclaration de classe principale ou une instruction System.out.println(...).

IntelliJ propose des modèles, c'est-à-dire des abréviations courtes qui se développent en constructions de code complètes lorsqu'elles sont tapées :

Exemples :

sout: se développe en :
```
System.out.println();
```

psvm se développe en :

public static void main(String[] args) {

}

fori se développe en :

  for(int i = 0; i < ...; i++) {
    ...
  }

Plus de modèles en direct

Pour une liste complète des modèles, consultez Paramètres -> Éditeur -> Modèles en direct -> Java.

Méthodes générées

En plus de modifier le code existant, l'option de refactorisation d'IntelliJ (⌥)(⌥) vous permet également de générer du code prêt à l'emploi, par exemple la méthode equals.

La méthode equals est nécessaire pour comparer si différents objets sont sémantiquement équivalents.
Exemple :

  Point p1 = new Point(2, 3);
  Point p2 = new Point(2, 3);
  System.out.println(p1 == p2); // returns false, these are different objects!
  System.out.println(p1.equals(p2)); // returns true, these objects are equal!

Écrire une méthode equals est principalement un code standard, le seul détail pertinent est quels champs d'objet doivent être considérés pour la comparaison.
Command + N vous permet d'ouvrir un menu contextuel pour sélectionner quels champs doivent être utilisés pour la méthode equals générée.

Profils d'exécution

Les profils d'exécution définissent comment votre code est compilé et démarré.
Intuitivement, on pourrait penser que c'est trivial, car il y a des triangles verts invitants ("▶") partout dans l'éditeur.
Cependant, par défaut, l'IDE ne sait rien d'un système de build que nous pourrions utiliser.

Attention aux configurations d'exécution par défaut

Les configurations d'exécution par défaut sont pour des projets Java minimaux, c'est-à-dire des projets sans paramètres et sans dépendances. Elles ne déclenchent pas Maven ; en utilisant les triangles verts, vous ne bénéficierez pas des avantages d'un système de build.

Avant de pouvoir développer sur un projet Maven, nous devons indiquer à l'IDE quelles sont nos intentions :

Quelle configuration du système de build utiliser
Ce qui doit se passer lorsque nous "exécutons" notre projet

Chargement de la configuration du système de build

IntelliJ est souvent bon pour deviner à partir des fichiers trouvés dans un projet.
Cependant, il est plus fiable de dire explicitement à IntelliJ quel type de projet nous avons.
- Comme vous vous en souvenez d'une précédente leçon, des bibliothèques supplémentaires peuvent être configurées dans le pom.xml de Maven (par exemple, JUnit).
- Maven modifie le classpath pour nous, nous pouvons utiliser ces dépendances.
- Si IntelliJ ne sait pas que nous utilisons Maven, le classpath reste inchangé et nous verrons beaucoup d'erreurs chaque fois que nous essaierons de travailler avec un artefact externe du JDK.
Pour dire explicitement à IntelliJ que nous utilisons le système de build Maven :
1. Faites un clic droit sur le fichier pom.xml à gauche
2. Sélectionnez Ajouter en tant que projet Maven -> Recharger

Configuration d'une configuration de lancement Maven

Nous pouvons indiquer à IntelliJ d'utiliser Maven lorsque le triangle vert en haut ("▶") est cliqué.
1. Cliquez sur le menu déroulant (à côté de l'icône "▶")
2. Sélectionnez "Modifier les configurations..."
3. Cliquez sur l'icône "+" puis sélectionnez l'option "Maven" (⌥) :
4. Donnez un nom à votre configuration et spécifiez la commande Maven (⌘) à exécuter :
5. Pour le champ Exécuter, omettez l'instruction initiale "mvn".
6. Exemple : si vous souhaitez appeler mvn clean package, chaque fois que vous cliquez sur "▶", tapez simplement clean package.
À partir de maintenant, vous pouvez exécuter votre programme avec Maven, en utilisant le lanceur supérieur.
Vous pouvez également répéter le dernier appel du lanceur avec : Control (⌃) + R

Définir plusieurs configurations d'exécution

Définissez plusieurs configurations d'exécution pour diverses commandes Maven, par exemple, une pour construire un jar, une pour exécuter uniquement des tests, une pour exécuter votre code, etc. Nous apprendrons bientôt comment utiliser efficacement la ligne de commande Maven (⌘) pour exécuter des phases spécifiques du système de build.

Débogage

En essence, le débogage se traduit par : "Gel votre programme à l'exécution et prenez tout le temps nécessaire pour inspecter son état."

Cas d'utilisation du débogueur

Les programmeurs novices recherchent souvent des bugs en ajoutant des instructions d'impression au code, c'est-à-dire que le code source est modifié et nous inspectons ensuite la sortie textuelle. Cependant, il y a plusieurs inconvénients :

Vous n'avez que les informations imprimées (et les informations dont vous avez besoin pourraient ne pas être incluses).
Il pourrait y avoir beaucoup de sorties, et cela peut s'accumuler rapidement.
Chaque fois que vous souhaitez adapter, vous devez modifier le code source, recompiler et provoquer à nouveau le bug. Cela peut prendre du temps.
Lorsque vous avez terminé, vous devez supprimer vos instructions d'impression, sinon la recherche de bugs futurs sera obscurcie par les impressions existantes. Le débogueur intégré à l'IDE est bien meilleur.
Le débogueur fait quelque chose de vraiment magique : il vous donne l'illusion d'exécuter le code source.
- Rappel : ce n'est pas le cas, Java est un langage compilé, votre code source n'est jamais exécuté !
Cela est extrêmement utile, car vous pouvez vous arrêter à n'importe quelle ligne du code et inspecter instruction par instruction ce qui se passe à l'exécution. Le débogueur a des fonctionnalités intéressantes :
Accès à toutes les variables, à tout moment.
Accès à l'ensemble de la pile d'appels.
Vous pouvez modifier l'état (changer l'état d'une variable).
Vous pouvez définir des conditions qui avancent rapidement l'exécution vers des situations spécifiques.

Les débogueurs ne sont pas seulement pour le débogage

Une exécution lente, étape par étape, est également très utile pour comprendre d'énormes bases de code. Si vous rejoignez un projet et que vous n'avez aucune idée de quel code est réellement pertinent pour une fonctionnalité, lancez simplement le débogueur et tracez quelles méthodes sont appelées.

Points d'arrêt basiques

Les points d'arrêt basiques sont la fonctionnalité de débogage la plus essentielle. Un point d'arrêt indique au programme de s'arrêter à une ligne donnée.

Cliquez sur la ligne où vous souhaitez que votre programme s'arrête.
Cliquez sur le symbole du bug (à côté du triangle vert).
Votre programme s'arrêtera à la ligne sélectionnée (si la ligne est accessible !)

Certains points d'arrêt ne sont pas ronds, mais affichés comme un symbole de diamant. Ce sont des lignes sans instruction, par exemple des définitions de méthode. Votre programme ne peut jamais s'arrêter là. Il est préférable de les supprimer immédiatement.

Variables

Les points d'arrêt sont assez inutiles sans également inspecter l'état du programme, car votre programme est gelé. Vous souhaitez voir ce qui entre dans vos variables. Il existe deux manières d'inspecter l'état des variables :

Survolez une variable : la valeur apparaît dans une annotation popup.
Ouvrez l'onglet des variables : celui-ci est utile pour les variables d'objet, car la plupart du temps, vous souhaitez inspecter leur état interne, pas seulement voir la référence de l'objet.

Clic droit pour modifier

L'onglet des variables vous permet également de modifier l'état des variables. Vous pouvez par exemple avancer rapidement à la 100ème exécution de boucle, mais en changeant le compteur de boucle. Faites un clic droit sur une valeur dans l'onglet des variables et choisissez définir la valeur.

La plupart du temps, un bug apparaît sur une série de nombreuses instructions. Pour le trouver, vous devez retracer l'exécution étape par étape et inspecter comment les valeurs des variables changent (et trouver où ça va mal). Le débogueur IntelliJ a juste les bons boutons pour ce genre de navigation :

Step over : vous amène à l'instruction suivante.
Step into : vous amène à l'intérieur de l'appel de méthode actuel.
Step out : vous amène à la méthode appelante (voir la pile d'appels affichée en bas à gauche).
Step to cursor : vous amène à l'endroit où se trouve votre curseur.

Utilisez le force touch (sur Mac)

Sur MacOS, vous pouvez utiliser le force touch sur une ligne pour accéder rapidement à Step to cursor. Le débogueur avance ensuite rapidement à l'endroit où vous avez cliqué.

Expressions et montres

Parfois, vous voulez rapidement évaluer une expression complexe, plutôt que de vérifier l'état d'une seule variable.
Bien sûr, vous pourriez modifier le code source pour introduire une variable intermédiaire, mais nous avons déjà discuté des raisons pour lesquelles changer le code source pour le débogage n'est pas optimal.
Heureusement, le débogueur est là pour vous aider :
- Cliquez sur le symbole de calculatrice et saisissez votre expression :
  - Il utilise la syntaxe Java standard, donc si vous avez une variable int nommée foo, vous pouvez simplement saisir foo * 42 pour calculer le résultat immédiat.
- Vous pouvez également maintenir la touche Option (⌥) en survolant une expression plus complexe dans votre code, par exemple foo * 42 + 8.
  - Une annotation contextuelle apparaîtra pour vous indiquer la valeur de l'expression.
  - Cela est particulièrement utile pour les instructions de retour qui calculent un résultat sans variable intermédiaire supplémentaire.
Enfin, vous voudrez souvent suivre la valeur d'une expression au fur et à mesure que l'exécution de votre programme progresse.
- Cela est possible avec les Montres.
- Pensez à une montre comme à une variable supplémentaire, qui est basée sur des variables dans le code source, mais qui n'existe que dans le débogueur.
- Pour ajouter une montre : cliquez simplement sur le symbole + en bas à gauche et entrez l'expression à évaluer pour votre montre.
- Au fur et à mesure que l'exécution de votre programme continue, votre montre apparaîtra dans l'onglet des variables, à côté de toutes les variables "réelles" et vous pourrez suivre sa valeur.

Utilisez le glisser-déposer

Vous n'avez pas besoin de créer des montres à partir de zéro, vous pouvez également faire glisser des variables existantes dans l'onglet des montres et modifier leur définition d'expression.

Points d'arrêt conditionnels

Enfin, souvent un bogue n'est pas associé à une ligne de code spécifique, mais plutôt à une valeur de variable spécifique.
Cela signifie que le point d'arrêt pourrait être atteint des centaines de fois, avant que vous atteigniez réellement l'état que vous souhaitez inspecter.
- Pensez à une boucle for, où le bogue n'apparaît qu'après 100 itérations.
- Vous ne voulez pas cliquer sur le bouton "continuer" 100 fois...
Heureusement, les points d'arrêt peuvent être "améliorés" en points d'arrêt conditionnels, c'est-à-dire des points d'arrêt qui ne bloquent l'exécution que si une certaine condition est remplie.
- Exemple : vous pouvez choisir comme condition que le compteur de boucle doit être supérieur à 100.
Pour transformer un point d'arrêt en point d'arrêt conditionnel, il vous suffit de cliquer avec le bouton droit sur son cercle rouge et de choisir définir la condition.
- La condition fonctionne à nouveau comme du code Java, vous pouvez écrire par exemple loopCounter >= 100.

Ne pas supprimer, désactiver

Désactivez les points d'arrêt conditionnels lorsque vous n'en avez plus besoin. Définir les bonnes conditions prend du temps, et vous pourriez avoir besoin de votre point d'arrêt à nouveau. Ne le supprimez pas, cliquez simplement avec le bouton droit et désactivez votre point d'arrêt. Vous pouvez le réactiver plus tard, lorsque vous en aurez à nouveau besoin.

Bonus : Matrice de dépendance

Les IDE ne traitent pas seulement des lignes de code individuelles, mais peuvent également vous fournir des informations sur les macro-structures de votre code.
Un exemple est la matrice de dépendance :

Chaque ligne et colonne représente une classe, chaque cellule indique combien de fois une classe appelle ou référence son homologue.
La matrice est automatiquement triée de bas en haut, c'est-à-dire que les classes en bas sont celles qui sont les plus utilisées, tandis que celles en haut sont les moins utilisées.
La matrice donne également un aperçu de constructions suspectes, c'est-à-dire des références cycliques, qui sont représentées par des carrés rouges.

Utilisez la matrice pour vérifier les modèles architecturaux, par exemple MVC

La matrice de dépendance est un moyen efficace d'analyser si un projet respecte le modèle MVC : Le Modèle ne s'occupe que des données et ne doit pas avoir d'appels au Contrôleur (logique) ou à la représentation (Vue). Le package Modèle doit être le plus bas dans la matrice. Le Contrôleur change l'état du modèle, mais ne se soucie pas de la représentation. Il a moins d'utilisations que le modèle, mais plus que la vue (personne n'appelle la vue). Les classes du package Contrôleur doivent être situées entre le modèle et la vue dans la matrice.

Littérature

Inspiration et lectures supplémentaires pour les esprits curieux :

Combinaisons de touches

Utilisation	Combinaison de touches
Rechercher dans tous les fichiers	Double `s hift`
Fichier de code récent	`Command + E`
Action	`Shift + Command + A`
Reformater le code	`Command shift + L`
Afficher la structure du fichier	`Command + F12` (+ `Fn` sur ordinateurs portables)
Suivre l'appel de méthode	`Command` + Cliquez sur la méthode

Combinaisons de touches

Téléchargez et imprimez le tableau de référence des combinaisons de touches, surlignez et mémorisez les combinaisons de touches les plus courantes. Cela accélérera considérablement vos flux de travail.

Environnements de Développement Intégrés

Au-delà de votre éditeur de texte standard

Coloration syntaxique

Mise en forme automatique du code

Profils de mise en forme

Checkstyle comme profil de mise en forme

Navigation

Inspecter la structure du fichier

Recherche structurée

Filtres

Refactorisation

Renommage avancé

Changement de signatures

Extraire une méthode

Valeurs magiques en constantes

Champs en paramètres de méthode

Expression en variable

Complétion de code

Complétion de base

Complétion d'appel de méthode

Modèles en direct

Méthodes générées

Profils d'exécution

Chargement de la configuration du système de build

Configuration d'une configuration de lancement Maven

Débogage

Cas d'utilisation du débogueur

Points d'arrêt basiques

Variables

Navigation étape par étape

Expressions et montres

Points d'arrêt conditionnels

Bonus : Matrice de dépendance

Littérature

Combinaisons de touches