Installez votre environnement de développement Java avec Eclipse

Vous avez créé votre premier programme Java. Nous abordons maintenant les fonctionnalités de base qui font d’Eclipse un IDE très pratique.

Découvrez l’écran principal

L’écran principal représente l’interface qui s’affiche quand on ouvre Eclipse.

Quand vous ouvrez l’IDE, vous avez trois sections principales :

• le package explorer (ou project explorer) ;

• l’éditeur de code ;

• des vues en bas, dont la console. Il y a aussi des vues secondaires à droite de l'interface.

Le package explorer

En cliquant sur le bouton droit dans une zone vide du package explorer, un menu contextuel s'ouvre. On y retrouve les items du menu principal d'Eclipse les plus pertinents pour le package explorer. Par exemple, l'item du menu contextuel New → Project... correspond au menu Eclipse File → New → Project... Voici quelques exemples d'utilisation du Package Explorer :

• avec le menu File → New → Project..., vous pouvez voir tous les types de projets que vous pouvez créer. Nous verrons notamment dans le chapitre suivant ce qu'est Maven et comment l'utiliser ;

• avec le menu File → Import..., vous pouvez reprendre un projet existant sur votre ordinateur ;

• si vous avez un code source Java avec une méthode main, vous pouvez le lancer directement en cliquant avec le bouton droit sur l'item de ce fichier et choisir Run As → Java Application.

L'éditeur de code

L'éditeur de code vous permet de coder directement dans les fichiers sources. Chaque fichier est représenté par un onglet. La saisie du code est assistée et différentes actions sont possibles pour vous faire gagner du temps. Nous allons le voir tout au long de ce chapitre et des suivants.

Vous avez remarqué qu'avec toutes ces fenêtres, l'éditeur de code ne représente qu'une partie de votre écran ? Si vous travaillez sur un écran de taille modérée, comme sur un ordinateur portable, vous pouvez agrandir l'éditeur de code temporairement. Pour cela :

• cliquez deux fois sur l'en-tête de l'onglet contenant le nom du fichier ;

• votre éditeur est cette fois en plein écran ;

• cliquez à nouveau deux fois sur cet en-tête d'onglet ;

• votre éditeur est revenu à la taille précédente. Cette manipulation très pratique est en fait valable pour tous les onglets d'Eclipse !

Les vues

Eclipse propose beaucoup de vues, et avec l'expérience, vous choisirez celles qui vous conviennent le mieux en fonction des vos préférences et des projets que vous traiterez. Si vous êtes bien en perspective Java (pour rappel, c'est le menu Perspective → Open Perspective → Java), vous avez notamment accès aux vues :

• problems : elle recense l'ensemble des erreurs de syntaxe et de compilation de votre code ;

• console : elle représente le résultat de l'exécution de votre code.

Déboguez dans Eclipse

Le débogueur intégré est l’un des éléments les plus pratiques d’Eclipse. Si vous avez beaucoup de code et qu’il y a un problème quelque part, un bon moyen de vérifier où se trouve l’erreur est de déboguer. En effet, beaucoup d'erreurs ne sont pas des problèmes de syntaxe, mais des comportements non souhaités ou un message d'erreur du JDK (on parle le plus souvent d'exception).

Comme ce n’est pas une erreur de syntaxe, vous ne pouvez pas être sûr de l’emplacement du problème. Avec un débogueur, vous pouvez inspecter votre code en spécifiant des points de départ et de fin. Cela vous permet de vérifier votre code section par section, ce qui aide à comprendre comment il fonctionne et où les problèmes ont commencé.

Pour vous montrer comment faire cela en utilisant le débogueur d’Eclipse, nous allons d’abord faire une petite modification dans le code que nous avons utilisé :

package com.openclassrooms;

public class HelloWorld {
    
    public static void main(String[] args) {
        int i;
		for (i = 0; i < 5; i++) {
			System.out.println("Bienvenue dans Eclipse !");
		}
		
		System.out.println("C'est la fin !");
    }
}

Maintenant que vous avez le code qu’il vous faut, suivez la vidéo ci-dessous pour apprendre à déboguer avec Eclipse.

Déboguer demande un peu d’entraînement, nous allons donc décomposer le processus. N’hésitez pas à regarder la vidéo plusieurs fois !

Choix des points d'arrêts

Pour arrêter et démarrer un programme, nous avons besoin de points d'arrêts, ou breakpoints. C’est ce qui vous permet d’arrêter le programme là où vous l’avez décidé. Mettons un breakpoint au niveau de la ligne où le code imprime notre message. Pour ce faire, rendez-vous au numéro de ligne 8, clic droit et cliquez sur Toggle breakpoint. Un petit point bleu apparaîtra à côté du numéro de ligne. Vous pouvez aussi l’enlever en cliquant sur Disable breakpoint.

Mettez aussi un breakpoint à la ligne 11, pour l'affichage du message final.

Exécution en mode débogage

Maintenant, trouvez le bouton « Debug as... » dans votre barre d’outils, et cliquez dessus. Il ressemble à ça :

Une fenêtre de dialogue apparaîtra pour vous demander de changer la perspective pour faire apparaître les fenêtres du débogueur. Acceptez le changement.

Sur le côté gauche, vous pourrez voir l’onglet Débogage. Vous voyez le surlignage vert sur println ? Il montre la ligne qui n’a pas encore été lancée. Vous pouvez le vérifier en regardant la console : aucune ligne affichée ! C’est la preuve que le programme a été lancé, puis arrêté juste avant le point d’arrêt.

Sur le côté droit, la fenêtre affiche les variables à ce moment précis. Vous pouvez voir que "i" est égal à 0, ce qui signifie que le programme est entré dans la boucle mais n’a pas encore commencé la seconde boucle. Si vous retournez dans l’onglet Débogage, vous pourrez voir où il s’est arrêté. Vous pouvez avancer dans le programme en cliquant sur l'icône Step Over dans la barre d’outils de l’onglet de débogage, ou sur la barre d’outils principale, comme indiqué ci-dessous.

Vous pouvez tester les autres actions pas à pas comme Step Into et Step Return. Suivez le screencast ci-dessus pour en savoir plus. Cliquez ensuite sur Step Over pour continuer d’itérer le programme. Pour pouvez aussi cliquer sur Resume (flèche verte de la barre débogage), pour vous emmener directement au deuxième breakpoint, à la ligne 11. Si vous continuez de cliquer sur Step Over, vous verrez le message final s'afficher, puis c'est la fin du programme.

Vous avez fini de déboguer ! Pour sortir de la perspective, cliquez sur Window et Reset perspective. Voyons à présent comment coder des tests et les exécuter avec JUnit dans Eclipse.

Testez vos méthodes avec JUnit

JUnit est la bibliothèque Java la plus répandue pour coder des tests.

Quand vous codez de plus en en plus de fonctionnalités, tester manuellement l'exécution de l'application et toutes ses fonctionnalités est une activité répétitive et peu créative. De plus, coder une fonctionnalité peut avoir un impact à un autre endroit de l'application. Donc, si l'on est rigoureux, il faudrait retester toute l'application à chaque développement ! Afin de pallier ces tâches fastidieuses, le développeur code des tests qui seront exécutés à la demande et feront le travail automatiquement ! On code ces tests une fois, mais on va pouvoir les exécuter mille fois !

Les tests les plus répandus sont les tests unitaires ou TU. Ils testent une "chose" à la fois : une fonction, une méthode, un comportement, de manière isolée du reste. JUnit permet donc de coder des tests en Java, et Eclipse apporte une interface graphique pour faciliter la conception et l'exécution de tests JUnit.

Création du test JUnit

Nous allons créer une méthode dans notre classe HelloWorld pour ajouter deux nombres. Insérez le code ci-dessous dans la classe HelloWorld, par exemple entre la ligne 12 et la ligne 13.

	public int ajouter(int num1, int num2) {
		return num1 + num2;
	}

Maintenant, nous allons coder une méthode pour tester si la fonction "ajouter" fonctionne correctement. Allez dans File → New →  Test JUnit

Vous pouvez nommer le test en ajoutant « Test » après le nom de la méthode. C'est une convention de nommage usuelle en Java. Dans le cas présent, je l’ai appelé HelloWorldTest avant de cliquer sur Finish. Eclipse vous propose alors d'ajouter la bibliothèque JUnit à votre projet. Validez cette proposition.

Votre test est créé et apparaît en tant que classe et fichier séparé dans le package explorer.

Vers le haut du fichier, une ligne commençant par le mot clé import indique que le code de test va utiliser  org.junit.jupiter.api.Assertions. Cette bibliothèque Java vous permettra d’utiliser une fonction appelée assertEquals() qui vous aidera à tester vos résultats facilement. Voici les étapes pour modifier la fonction de test vide par défaut :

1. Renommez votre fonction de test selon la nomenclature Java. Ici, appelez-la  public void testAjouter().

2. Créez un nouvel objet à utiliser par la classe HelloWorld dans le test. Le nouvel objet se nomme testHelloWorld.  HelloWorld testHelloWorld = new HelloWorld();

3. Appelez la fonction à tester (c'est ajouter()), et stockez le résultat dans une variable somme de type entier :int somme = testHelloWorld.ajouter(2, 3);

4. Testez si le résultat de la méthode Ajouter correspond au résultat attendu, c'est-à-dire 5. Pour cela, on utilise une fonction de JUnit qui se nomme assertEquals. Cette fonction prend en premier paramètre la valeur attendue, et en deuxième paramètre la valeur à tester. La ligne de code est donc assertEquals(5, somme);

En résumé, la méthode de test modifiée est :

@Test
public void testAjouter() {
    HelloWorld testHelloWorld = new HelloWorld();
    int somme = testHelloWorld.ajouter(2, 3);
    assertEquals(5, somme);
}

Exécution du test JUnit

Maintenant, testons la méthode avec JUnit ! Clic droit sur le fichier de test. En l’occurrence, le fichier HelloWordTest.java. Allez dans Run As -> JUnit Test.

Vos résultats apparaîtront dans l’onglet JUnit à la place du package explorer.

L’exemple ci-dessus montre un test réussi. Un échec affichera une barre rouge. Par exemple, vous pouvez retourner sur la méthode Ajouter de la classe HelloWorld et changer le "+" en "-". Sauvez, et lancez à nouveau l'exécution du test. Regardez le résultat du test.

JUnit indique en plus, dans la vue Failure Trace, quelques détails sur l'erreur du test. Le test s'attendait au résultat 5 (somme de 2 et 3), mais a obtenu -1 (résultat de la modification effectuée en soustrayant 2 et 3).

Pour aller plus loin : le refactoring de code

Une des grandes forces d'Eclipse est de vous faciliter le développement. En particulier lorsque vous avez besoin de remettre votre code au propre. Vous travaillerez en équipe, et lorsque du code passe d'un développeur à un autre, il doit être le plus lisible et le plus clair possible. Il peut s'agir simplement d'écrire un code bien espacé, avec les retours de ligne corrects (formatage). Il peut s'agir aussi de nommer les variables de manière explicite, de regrouper les fonctions de manière logique, etc.

Cette tâche de retravailler le code pour qu'il soit plus clair s'appelle le refactoring. Voici un aperçu rapide et non exhaustif de ce que propose Eclipse. Certaines fonctionnalités nécessitent une certaine maîtrise de Java, donc nous verrons ici uniquement quelques exemples basiques.

Formatage du code

Il existe plusieurs conventions pour formater correctement du code. Eclipse en propose une par défaut. Et pour l'appliquer, c'est simple :

1. Ouvrez le code source de HelloWorld.java.

2. Choisissez une ligne de code et enlevez les espaces avant ce code. Vous pouvez aussi mettre deux lignes de code sur une seule ligne. Java autorise de faire cela, grâce au symbole ";" qui sépare bien les différentes instructions de code. Mais c'est moins lisible !

3. Allez dans le menu Source -> Format, ou bien saisissez le raccourci clavier CtrlMajF

4. Votre code est formaté !

Concernant le formatage, Eclipse vous permet de :

• Personnaliser le formatage. Cliquez sur le menu Window -> Preferences. Allez dans Java -> Code Style -> Formatter. Vous voyez alors le style de formatage proposé. Vous pouvez le modifier en allant dans Edit... Par exemple, vous pouvez changer les espaces insérés en début de ligne, ce qu'on appelle l'indentation. Faites quelques essais !

• Appliquer le formatage à chaque sauvegarde. Eclipse peut vous formater le code à chaque fois que vous sauvegardez. Plus besoin de se soucier de bien présenter le code ! Pour l'activer, c'est très simple : Toujours dans Window -> Preferences, allez dans Java -> Editor -> Save Actions. Cochez les cases Perform the selected actions on save et Format source code. Amusez-vous à refaire les étapes 1 et 2 ci-dessus, et sauvez le fichier sans faire les étapes 3 et 4. Votre code est alors automatiquement formaté en même temps que d'être sauvé !

Exemple simple de refactoring : renommage de méthode

Nous allons changer le nom de la méthode "ajouter". Au lieu de modifier le nom ajouter dans le fichier HelloWorld.java, nous allons utiliser le refactoring d'Eclipse :

1. Cliquez deux fois sur le nom de la méthode ajouter afin de sélectionner ce mot en entier.

2. Allez sur menu Refactor -> Rename... (via le menu d'Eclipse ou par le menu contextuel avec le bouton droit).

3. Le mot ajouter est encadré et vous pouvez le changer. Mettez à la place sommeNombres, par exemple, et appuyez sur Entrée. La méthode a changé de nom !

Tout simplement parce qu'Eclipse a modifié ce nom partout où il était utilisé. Et dans notre cas, il a modifié aussi le test unitaire que l'on a créé précédemment ! Ouvrez le test unitaire HelloWorldTest.java et constatez. Le test appelle bien à présent la fonction sommeNombres et non ajouter.

Ce mécanisme de renommage est puissant et assez fiable. Si, à un autre endroit du code, vous aviez une chaîne de caractères contenant le mot ajouter, il n'aurait pas été modifié ! Eclipse comprend le code et ne remplace le nom que là où c'est nécessaire. Dans un projet réel d'entreprise, cette fonctionnalité peut vous faire gagner un temps énorme !

En résumé

Ce chapitre était dense, félicitations pour l'avoir mené jusqu'au bout ! N'hésitez pas à le relire et à bien pratiquer les exemples donnés. Avec Eclipse, vous avez réussi à :

• comprendre l'organisation des fenêtres et la notion de Perspective ;

• créer des points d'arrêts dans votre code pour le déboguer ;

• déboguer votre code et utiliser les points d'arrêts que vous avez créés ;

• comprendre ce qu'est un test unitaire ou TU, et créer votre premier code de TU ;

• exécuter votre TU ;

• effectuer un refactoring simple de code.

Vous allez encore apprendre beaucoup au chapitre suivant, en particulier comment structurer un vrai projet Java de manière professionnelle avec Maven, et ce que propose Eclipse pour vous faciliter la vie avec cet outil de structuration.