FAQ GénéraleConsultez toutes les FAQ

Quelques raccourcis clavier indispensables pour la programmation Java sous Eclipse :

Pour créer un projet Java, allez dans le menu File > New > Project... et localisez Java Project.
Dans l'assistant qui s'affiche, saisissez un nom pour le projet à créer et cliquez sur Finish.

Le Build Path est ce qui constitue le référencement des fichiers, répertoires, bibliothèques (jar), c'est-à-dire toute ressource nécessaire à la compilation d'un programme Java au sein d'Eclipse. Cet élément correspond de fait à l'option -classpath utilisée avec la commande javac, en ligne de commande.

Sous Eclipse, chaque projet Java possède un Build Path que l'on peut ajuster selon ses besoins. Il se configure via un clic droit sur le projet, puis Properties > Java Build Path. Sur cette page de préférences, on trouve notamment les onglets Source, Projects et Libraries, lesquels permettent de référencer différents types de ressources.

Au minimum un projet Java doit avoir un répertoire pour les fichiers source, lequel doit être défini dans l'onglet Source mais aussi, un JRE System Library défini dans l'onglet Libraries.

Bien que de base, un projet Java puisse se contenter de l'API standard de Java (fournie par le JRE ou le JDK) pour compiler et s'exécuter, il est rare que cela soit suffisant. De fait, vous pouvez agrémenter votre Build Path avec entre autres, des bibliothèques tierces.
L'ajout de ces bibliothèques est décrit ici Comment ajouter un JAR à mon projet ? .

Remarque : Dans Eclipse, il ne faut pas confondre Build Path et Class Path. Le Class Path concerne uniquement l'exécution d'un programme Java. Le principe est similaire à celui du Build Path et d'ailleurs ce dernier sert de base pour la constitution du Class Path mais le Class Path est propre à l'exécution et peut comporter d'autres ressources qui ne sont pas nécessaires lors de la compilation. Cf. Qu'est-ce que le Class Path d'un projet Java ?

Le Class Path est ce qui constitue le référencement des fichiers, répertoires, bibliothèques (jar), c'est-à-dire toute ressource nécessaire à l'exécution d'un programme Java au sein d'Eclipse. Il correspond bien évidemment au paramètre -classpath que l'on peut utiliser lors de l'appel des programmes Java, en ligne de commande.

Lors d'une première exécution de votre application Java, un Class Path est déterminé automatiquement. On peut toutefois le constituer spécifiquement et manuellement, à partir du menu Run > Run Configurations..., puis en ajoutant une configuration d'exécution de type Java Application (par exemple). Ainsi, une fois la configuration initiée (soit manuellement, soit lors de la première exécution de l'application), il est possible de l'ajuster en fonction de besoins particuliers, via l'onglet Classpath. Un Class Path est donc partie intégrante d'une configuration d'exécution d'un programme Java, au sein d'Eclipse.

Remarque : Dans Eclipse, il ne faut pas confondre Class Path et Build Path. Le Build Path concerne uniquement l'étape de compilation d'un programme Java. Le principe est similaire à celui du Class Path, puisqu'en effet, un Class Path est par défaut élaboré à partir du Build Path. Cf. Qu'est-ce que le Build Path d'un projet Java ?

Pour modifier les répertoires source et de compilation :

• Faites un clic droit sur le projet, menu Properties > Java Build Path, puis sélectionnez l'onglet Source.
  

• Sélectionnez Add folder pour ajouter un répertoire source supplémentaire.
• Sélectionnez Remove folder pour ne plus considérer un répertoire comme un répertoire source.
• Dans la zone Default output folder, vous pouvez changer le répertoire de compilation par défaut.
  

Pour ajouter un jar qui se trouve dans le workspace :

• Clic droit sur le projet, menu Properties > Java Build Path, onglet Librairies, puis bouton Add jar
  

• Clic droit sur le projet, menu Properties > Java Build Path, onglet Librairies, puis bouton Add external jar
  

• Clic droit sur le projet, menu Properties > Java Build Path, onglet Librairies, puis bouton Add Library
  

Pour ajouter un répertoire de fichiers Java compilés '.class' se trouvant dans le workspace :

• Clic droit sur le projet, menu Properties > Java Build Path, onglet Librairies, puis bouton Add Class Folder
  

Pour ajouter un répertoire de .class (fichiers Java compilés) qui se trouve en dehors du workspace :

• Clic droit sur le projet, menu Properties > Java Build Path, onglet Librairies, puis bouton Add External Class Folder
  

Lorsque dans Eclipse, on a par exemple deux projets A et B, où A a besoin de B pour compiler et s'exécuter, il peut être intéressant de les mettre en relation de façon explicite.

Pour référencer B au sein de A, il suffit de faire un clic droit sur le projet A, menu Properties > Java Build Path, puis onglet Projects.
Ensuite, il faut cliquer sur Add... et sélectionner le projet B qui doit apparaître dans la liste proposée.

Cette relation doit être à sens unique car B n'est pas censé avoir besoin de A pour fonctionner, ou alors c'est qu'il y a très probablement un problème d'architecture dans votre application.

L'avantage principal qu'un projet A référence un projet B, est tout simplement que cela évite :

• La compilation et le packaging (jar) du projet B pour pouvoir en faire usage dans le projet A. Les modifications de B sont donc instantanément disponibles dans A.
• La Javadoc de l'API du projet B est implicitement disponible, ainsi que bien évidemment son code source (inutile de passer par CTRL + SHIFT + T pour aller à la déclaration d'une classe de B).
• Aucun paramétrage supplémentaire n'est en principe nécessaire pour exécuter A, le classpath est déjà en phase.
  

Pour générer automatiquemet les getters et setters d'une classe, il suffit de faire :

• Clic droit sur la classe concernée (dans le Package Explorer ou l'éditeur Java), puis sélectionner le menu Source > Generate Getters and Setters
  

Pour générer automatiquemet les getters et setters d'une classe, il suffit de faire :

• Clic droit sur la classe concernée (dans le Package Explorer ou l'éditeur Java), puis sélectionner le menu Source > Generate Getters and Setters
  

Il faut configurer le positionnement automatique du point-virgule :
Allez dans le menu Window > Preferences > Java > Editor, dépliez typing et cochez Semicolons dans Automatically insert at correct position.

Il suffit ensuite de taper un point-virgule et quelle que soit la position du curseur dans l'instruction courante, il sera ajouté à la fin.

Pour aller d'une accolade { à l'autre } vous pouvez utiliser le raccourci clavier CTRL + SHIFT + P.
De plus un double-clic sur une accolade surligne tout le bloc jusqu'a l'accolade fermante.

Sur un fichier Java en cours d'édition, faites un clic droit, puis sélectionnez le menu Source > Organize Imports. Ceci correspond au raccourci clavier CTRL + SHIFT + O.

Cette commande est également applicable dans la vue Package Explorer, directement sur un package Java ou encore sur une sélection multiple de fichiers Java (à condition que le(s) fichier(s) et/ou répertoire(s) fassent partie d'un répertoire source).

Si la résolution automatique rencontre des homonymes, par exemple java.util.List et java.awt.List, une boite de dialogue vous demandera de sélectionner la bonne référence.

A noter que la réorganisation des imports permet de déclarer explicitement chacune des classes (donc sans l'astérisque 'x.y.*'), tout en ajoutant celles qui n'auraient pas encore été importées.
La réorganisation trie également les imports selon les packages et l'ordre alphabétique des classes importées.

Pour utiliser les nouveautés de Java 5 (autoboxing, generics etc..) sous Eclipse, vous avez deux solutions :

• Utiliser Eclipse 3.1 ou supérieur.
• Si vous avez une version antérieure à Eclipse 3.1, vous pouvez utiliser un plug-in qui gère les nouveautés de Java 5.
  Pour le télécharger, cf. http://www.genady.net/forum/viewtopic.php?t=31.
  Il faut ensuite l'installer en le dézippant dans le sous-répértoire plugins d'Eclipse et le configurer comme indiqué ici http://www.genady.net/forum/viewtopic.php?t=59.
  

Un JRE (Java Runtime Environment) n'embarque pas la Javadoc ou les sources de l'API standard de Java, donc si vous en avez besoin (ce qui est quasiment obligatoire lorsque l'on développe en Java), il faut avoir installé un JDK (Java Development Kit). Une fois que c'est fait, vous pourrez constater la présence du fichier src.zip, lequel contient tous les fichiers source (.java) de l'API standard. Et de fait, dans ces fichiers source, vous aurez également la Javadoc.

Donc, en référençant un JDK, automatiquement le fichier src.zip donne accès à la Javadoc. Concrètement, cela signifie qu'en survolant les classes de l'API standard, ou en affichant la view Javadoc, vous devriez pourvoir visualiser la Javadoc, voire même d'ouvrir le code source de cette API (via la touche F3 ou le CTRL + Clic gauche).

Si vous n'avez pas de JDK installé, que vous ne pouvez pas en installer, ou que pour X raison vous devez vous contenter d'un JRE, alors pour obtenir la Javadoc de l'API standard de Java malgré tout, vous avez les possibilités suivantes :

• En principe, dans les versions récentes d'Eclipse, vous ne paramétrez rien du tout, celui-ci sait déjà à quel URL aller chercher la Javadoc de l'API standard.
  Pour Java 6, l'URL est http://java.sun.com/javase/6/docs/api/, comme le montre ceci.
  
  Dans ce cas précis, l'inconvénient est qu'il faut être sûr d'avoir un accès Internet actif, sans quoi, la Javadoc ne sera évidemment pas disponible.
  

• Vous pouvez aussi vous débrouiller de rapatrier un fichier src.zip, en le plaçant dans le répertoire de votre JRE.
  Sur l'image ci-dessus, on peut d'ailleurs voir que cela a été fait ainsi, puisque le Source attachment pointe dessus. De fait, dans ce cas de figure, le paramétrage de la Javadoc location devient inutile mais cela ne pose pas de problème d'avoir les deux a priori.
  En revanche, ce qu'il faut évidemment éviter, c'est de paramétrer une version de src.zip qui ne corresponde pas à votre cas de figure.
  En principe, un JRE aura toujours la même API d'une version majeur à l'autre, donc l'URL de sa Javadoc ne changera pas, même suite au passage par exemple, d'un JDK/JRE 1.6.0_14 à 1.6.0_20. En revanche, cela sera beaucoup moins vrai pour les sources, donc le fichier src.zip doit vraiment être en phase avec la version de Java utilisée.
  
  
  

• Pour Configurer la Javadoc de l'API standard de Java :
  • Aller dans le menu Window > Preferences > Java > Installed JREs
  • Dans le panneau de droite, sélectionner le JRE
  • Cliquer sur le bouton Edit
  • Renseigner l'URL (ou le répertoire, ou l'archive)
  
  

• Pour Configurer la Javadoc d'une librairie utilisée dans un projet, par exemple la librairie Struts dont le jar du binaire est struts.jar.
  • Aller dans le menu Project > Properties > Java Build Path > onglet Libraries
  • Sélectionner le fichier struts.jar (ou le jar qui vous intéresse) puis ouvrir l'arborescence de cette librairie
  • Sélectionner l'élément Javadoc location
  • Cliquer sur le bouton Edit
  • Renseigner une URL similaire à ceci struts/docs/api/, qui est la racine de la Javadoc
  
  

• Configurer les sources de l'API standard de Java :
  • Aller dans le menu Window > Preferences > Java > Installed JREs
  • Dans le panneau de droite, sélectionner le JRE
  • Cliquer sur le bouton Edit
  • Renseigner l'URL (ou le répertoire, ou l'archive)
  A noter qu'il faut cibler un JDK et non pas un JRE car seul le JDK possède le code source. D'une manière générale, il est toujours préférable de cibler un JDK à cet endroit-là car, en plus de vous permettre de disposer des sources et de la Javadoc, certains outils ne sont utilisables qu'avec un JDK.
  

• Configurer le code source d''une librairie utilisée dans un projet, par exemple la librairie Struts dont le jar du binaire est struts.jar.
  • Aller dans le menu Project > Properties > Java Build Path > onglet Libraries
  • Sélectionner le fichier struts.jar (ou le jar qui vous intéresse) puis ouvrir l'arborescence de cette librairie
  • Sélectionner l'élément Source attachment
  • Cliquer sur le bouton Edit
  • Renseigner une URL similaire à ceci struts/src/, qui est la racine du répertoire source
  
  

Bouton droit sur le projet, menu Export... > Java > Javadoc, indiquez la destination et cliquez sur Finish.

• Lors de la première utilisation, vous devrez renseigner l'emplacement de l'utilitaire Javadoc, dans la première boite de dialogue.
• Vous avez la possibilité de sélectionner spécifiquement les packages/classes/répertoires source, pour lesquels vous souhaitez générer la Javadoc.
  

Bouton droit sur le projet, menu Export... > Java > JAR File > Next.

• Dans la 1ère page de l'assistant, vous devez spécifier le nom du fichier jar exporté, mais aussi sélectionner avec précision les classes et ressources à inclure dans le jar.
• Dans la 2ème page, il est possible (entre autres) d'ajouter une description du Jar généré au workspace.
• Dans la 3ème page, il est possible d'indiquer à Eclipse, soit de générer automatiquement le fichier MANIFEST (et éventuellement l'ajouter au workspace), soit d'utiliser un fichier MANIFEST existant (dans le workspace).
  Dans cette même page, il est possible de choisir la classe à exécuter automatiquement au lancement du jar.
  

• Fournir à l'assistant d'export votre propre fichier manifest (généré par un premier export éventuellement) dans lequel vous précisez les jars que vous utilisez en ajoutant la ligne suivante:
  

  Code text :

  Sélectionner tout

  Class-Path: log4j.jar, mysql-connector-java-5.1.6-bin.jar

Eclipse, depuis sa version 3.4 (Ganymede), offre un nouvel assistant d'export de JAR exécutable, qui inclut toutes les dépendances du projet (JARs externes) dans l'archive générée.

Avant de pouvoir utiliser cet assistant, il faut avoir exécuté le projet au moins une fois, c'est à dire avoir au moins une configuration de lancement.

Ensuite, faites un clic droit sur le projet, menu File > Export... > Java > Runnable JAR File > Next.
Dans la fenêtre de l'assistant, vous devez sélectionner la configuration de lancement et spécifier le nom du fichier jar exporté, puis valider (bouton "Finish").
Une fenêtre s'affiche vous demandant de revoir les licences des bibliothèques qui seront décompressées et recompressées dans le JAR exporté, pour voir si elles permettent ce cas d'utilisation.

Bouton droit sur la classe à exécuter dans le package explorer Run as > Run onglet (x)= Arguments

Dans Program arguments : les arguments de l'application (de la méthode main(String[] args))
Dans VM arguments : les paramètres de la machine virtuelle

Après avoir lancé l'application au moins une fois pour avoir une configuration de lancement, allez dans le menu Run > Run Configurations et sélectionnez la configuration qui vous intéresse parmi la liste et activez l'onglet onglet (x)= Arguments

Dans Program arguments : les arguments de l'application (de la méthode main(String[] args))
Dans VM arguments : les paramètres de la machine virtuelle

Parfois, on peut être tenté de placer des fichiers de configuration, dans le répertoire de compilation (application.properties, fichiers .xml, ...).
Cependant, par défaut Eclipse vide ce répertoire lors d'une compilation complète (lorsque l'on sélectionne par exemple le menu Project > Clean...).

Il est possible de paramétrer Eclipse pour qu'il ne fasse plus ce ménage, via le menu Window > Preferences > Java > Compiler > Building > Output folder, en décochant Scrub output folder when cleaning projects.

Cependant, une solution bien plus propre et largement préférable est de créer un répertoire dans lequel vous ne placez que vos fichiers de configuration.
Donc, tout simplement :

• Créez un répertoire nommé par exemple config au sein du projet.
• Faites ensuite un clic droit dessus, puis sélectionnez le menu Build Path > Use as Source Folder.
  

Les templates sont des bouts de code accessibles via des raccourcis typographiques.

Par exemple, tapez sys quelque part dans votre code source d'une classe Java et appuyez sur CTRL + Espace.
Ceci provoque l'affichage d'une fenêtre, comme indiqué sur l'image suivante :

Sélectionnez sysout - print to standard out et appuyez sur Entrée.
Et voilà ! Le code System.out.println(); a été inséré.

Parmi les templates prédéfinis, ceux-ci vous permettent de générer des squelettes de code qui vous aiderons à programmer plus rapidement.

Autres exemples :

• Créer une instance d'une classe :
  • Tapez new puis CTRL + Espace
  • Sélectionnez le template new - create new Object et le code type name = new type(arguments); est généré, avec les champs à compléter encadrés, et le premier mot type sélectionné.
  • Sans déplacer le curseur, saisissez Integer en lieu et place du mot type et vous constaterez que le troisième champ (l'appel du constructeur) se modifie simultanément !
  • Appuyez sur Tab pour passer au champ suivant (le nom de la variable) et donnez le nom que vous souhaitez à votre variable (par exemple : monInteger).
  • Appuyer de nouveau sur Tab et vous passez à l'argument du constructeur de Integer, dans lequel vous pouvez initialiser votre variable (par exemple : 10).
  • Pour finir, appuyer sur Entrée et votre votre variable est initialisée et les cadres entourant les éléments à adapter disparaissent.
• Générer rapidement une boucle d'itération :
  • Tappez for puis CTRL + Espace et complétez les éléments encadrés
  
  

• Cliquez sur le bouton New... et remplissez les valeurs qui suivent
• Name : <p>
• Context : Javadoc
• Description : <p></p>
• Pattern :
  

<p>${word_selection}${}</p>${cursor}

• Cliquez sur le bouton New... et remplissez les valeurs qui suivent
• Name : lg
• Context : Java
• Description : Instanciation de l'objet de log
• Pattern :
  

1
2
/** Traces */ 
private static final Log log = LogFactory.getLog(${enclosing_type}.class);

Remarque : Les templates sont importables et exportables, ce qui est notamment pratique pour homogénéiser le développement d'applications en équipe. Ils ne sont pas réservés au langage Java (et autres langages liés) mais pour pouvoir les utiliser dans d'autres langages/technos, il faut qu'un menu dédié soit disponible dans les préférences. C'est l'ajout de plug-ins embarquant ce genre de fonctionnalité qui peut permettre d'en disposer.

Le framework de test JUnit est très utilisé et est disponible sur http://junit.org/
Il est complètement intégré à Eclipse et vous n'avez rien besoin d'installer.

Dans le package explorer bouton droit sur une classe à tester > New JUnit test case et vous aurez un assistant déjà renseigné.

• La deuxième page de l'assistance permet de sélectionner les méthodes et constructeurs à tester.
• Il est conseillé de placer les classes JUnit dans le même package que la classe à tester (fait par défaut), mais dans un répertoire de sources différent.
• Si vous codez d'abord la classe de test (façon Extreme Programming), faites File > New > JUnit test case
  

Dans la marge gauche d'une classe, vous pouvez ajouter (ou retirer) un point d'arrêt, en double cliquant sur la ligne souhaitée. A noter que vous obtiendrez le même résultat en passant par un clic droit > Toggle breakpoint.
Ce point d'arrêt entre en action lorsque vous exécutez votre programme en mode Debug et que la ligne où il se trouve doit être exécutée.
Eclipse gèle alors l'exécution du programme et attend une action de l'utilisateur pour savoir comment le débogage doit continuer.

Vous pouvez mettre des breakpoints partout ou cela vous semble nécessaire mais uniquement à des endroits cohérents.

Les actions possibles du mode Debug :

• Dans la view Debug : Step into (F5) permet de rentrer dans une méthode
• Dans la view Debug : Step over (F6) permet de poursuivre l'exécution en mode pas à pas.
• Dans la view Debug : Step return (F7) permet de poursuivre l'exécution jusqu'à sortir de la méthode courante.
• Dans la view Debug : Resume (F8) permet de reprendre l'exécution normalement ou s'arrêter uniquement si un autre point d'arrêt est rencontré.
• Dans la view Variables : Vous pouvez consulter les valeurs des variables
• Dans la view Variables : Une variable en rouge est une variable qui vient d'être modifiée
• Dans la view Variables : Bouton droit sur une variable : Edit value permet de changer à chaud la valeur
• Dans la view Breakpoints : Vous pouvez activer/désactiver des breakpoints sans les retirer
• Dans la view Breakpoints : Le bouton j! permet de mettre un breakpoint sur toutes les Exceptions du programme
• Dans la view Breakpoints : à l'aide de la flèche noire orientée vers le bas, activez Show working Sets. Puis dans le même menu, sélectionnez Working Sets, Exception et donnez un nom. Voilà, vous avez maintenant un groupe d'Exceptions sous ce nom, que vous pouvez activer d'un simple clic de souris.