Développons en Java avec Eclipse13/07/2003
6. Le Java Development Tooling
(JDT)
6.1. Les projets de type
Java
6.1.1. La création
d'un nouveau projet Java
6.1.2. Les paramètres
d'un projet java
6.2. La création
d'entité
6.2.1. Les
packages
6.2.2. Les classes
6.2.3. Les
interfaces
6.3. Les vues du JDT
6.3.1. La vue
"Packages"
6.3.2. La vue
"Hiérarchie"
6.4. L'éditeur de code
6.4.1. Utilisation de
l'éditeur de code
6.4.2. L'éditeur et la
vue Structure
6.4.3. La coloration
syntaxique
6.4.4. Utilisation des
modèles
6.4.5. La gestion des
importations
6.4.6. La génération
de getter et setter
6.4.7. Formater le
code
6.4.8. Les erreurs
6.5. Exécution d'une
application
6.6. Génération de la
documentation javadoc
6. Le Java Development Tooling
(JDT)
Le JDT est inclus dans Eclipse pour fournir des outils de
développement en Java. Il inclus plusieurs plug-ins et
apporte :
-
les perspectives "Java" et "Navigation Java"
-
les vues "Packages" et "Hierarchie"
-
les éditeurs "Java" et "Scrapbook"
-
les assistants : pour créer de nouveaux projets,
packages, classes, interfaces, ...
Dans le workspace, il définit un projet de type particulier
pour les projets java. L'arborescence de ces projets
contient un fichier particulier nommé .classpath qui
contient la localisation des bibliothèques utiles à la
compilation et à l'exécution du code.
6.1. Les projets de type
Java
Pour pouvoir développer des entités en java, il faut les
regrouper dans un projet de type Java.
6.1.1. La création
d'un nouveau projet Java
Dans la perspective "Java", il y a plusieurs possibilités
pour lancer l'assistant de création d'un nouveau projet :
-
sélectionner l'option "Projet" du menu "Fichier/Nouveau"
-
sélectionner l'option "Nouveau/Projet" du menu contextuel
de la vue "Packages"
L'assistant demande le type de projet à créer.
Pour demander directement la création d'un projet "Java",
il suffit de cliquer sur l'îcone  de la
barre d'outils.
L'assistant demande le nom du projet.
Ce nom de projet ne doit pas déjà être utilisé dans le
workspace courant sinon un message d'erreur est affiché.
En cliquant sur "Fin", le projet est créé avec des
paramètres par défaut.
Pour modifier certains paramètres avant la création du
projet, suffit de cliquer sur le bouton "Suivant" :
La modification de ces paramètres sera détaillée dans la
section suivante. Une fois les paramètres modifiées,
cliquer sur "Fin".
Le projet apparait dans la vue "Packages".
6.1.2. Les paramètres
d'un projet java
Les principaux paramètres d'un projet peuvent être modifiés
:
-
lors de l'utilisation de l'assistant à la création du
projet
-
en sélectionnant le menu contextuel "Propriétés" sur le
projet sélectionné dans la vue "Packages" et de choisir
"Chemin de compilation Java"
Les propriétés "chemin de compilation Java" sont regroupées
dans quatres onglets :
|
Onglet
|
Rôle
|
|
Source
|
Permet de préciser le répertoire qui va contenir les
sources
|
|
Projets
|
Permet d'utiliser d'autre projet avec le projet courant
|
|
Bibliothèques
|
Permet d'ajouter des bibliothèques au projet
|
|
Ordre et exportation
|
Permet de préciser l'ordre des ressources dans la
classpath
|
L'onglet "Source" permet de préciser le répertoire qui va
contenir les sources : par défaut, c'est le répertoire du
projet lui même (l'option "utiliser le dossier projet en
tant que dossier source" est sélectionné).
Pour stocker les ressources dans un répertoire dédié, il
faut sélectionner l'option "Utiliser les dossiers sources
contenus dans le projet". La liste permet de sélectionner
le ou les répertoires.
Le bouton "Créer un dossier" ouvre une boîte de dialogue
qui demande le nom du répertoire.
Il suffit de saisir le nom, par exemple "sources" et
cliquer sur "OK"
Par défaut, dès qu'un premier répertoire contenant les
sources est sélectionné, Eclipse propose de créer un
répertoire bin qui va contenir le résultat des différentes
compilations.
La réponse à la question est libre mais il est préférable
de répondre "Oui".
L'onglet "Projets" permet d'ajouter des projets contenus
dans le workspace au classpath.
Il suffit de cocher les projets à inclure dans le
classpath.
L'onglet "Bibliothèques" permet d'ajouter des bibliothèques
externes au projet notamment des fichiers .jar.
Les bibliothèques incluses dans le classpath du projet
courant sont affichées dans la liste.
Pour ajouter sur une nouvelle bibliothèque contenue dans le
workspace, il suffit de cliquer sur "Ajouter des fichiers
jar".
Pour ajouter des fichiers jar qui ne sont pas contenus dans
le workspace, il suffit de cliquer sur "Ajouter des
fichiers jar externes".
Une boite de dialogue permet de sélectionner le fichier
jar. En cliquant sur "Ouvrir", le fichier jar est ajouté
dans la liste.
Le bouton "Avancées" permet d'ajouter d'autres entités au
classpath notamment des répertoires qui contiennent des
fichiers compilés.
Le bouton "Editer" permet de modifier les caractéristiques
de la bibliothèque (son chemin d'accès dans le cas d'un
fichier jar).
Le bouton "Supprimer" permet de supprimer une bibliothèque
du classpath.
L'onglet "Ordre et exportation" permet de modifier l'ordre
des bibliothèques dans le classpath, de préciser la cible
des éléments générés (le répertoire qui va les contenirs)
et de définir les ressources qui seront utilisables par les
autres projets du workspace lorsque le projet sera lié avec
eux.
6.2. La création
d'entité
Dans un projet Java, il est possible de créer différentes
entités qui entrent dans sa composition :
-
les packages
-
les classes
-
les interfaces
Il est possible de créer les packages à l'avance même si
ceux ci peuvent être créer automatiquement en même temps
qu'une classe qui la contient.
Pour créer un nouveau package, il y a plusieurs
possibilités :
-
cliquer sur la flèche de l'icône
 de la
barre d'outils de la perspective java et sélectionner
"Package"
-
cliquer sur l'icône
 de la barre d'outils de la
perspective Java
-
sélectionner l'option "Package" du menu "Fichier /
Nouveau"
L'assistant demande le nom du package.
Cliquer sur "Fin", pour créer le nouveau package. Le
package apparait dans la vue "Packages".
La création d'une classe peut se faire :
-
en cliquant sur l'îcône
 dans la
barre d'outils
-
en sélectionnant l'option Classe du menu
« Fichier/Nouveau »
Un assistant facilite la création de la classe.
L'assistant demande de renseigner les différentes
caractéristiques de la nouvelle classe : le projet et
le package d'appartenance, le nom, les modificateurs,
la classe mère, les interfaces implémentées. Enfin, il est
possible de demander à l'assistant de générer
certaines méthodes.
Si un projet ou un package est sélectionné dans la vue
package, celui ci est automatiquement repris par
l'assistant.
L'ajout d'une interface implémentée se fait en
la sélectionnant dans une liste.
Pour ajouter une interface, il suffit de double cliquer
dessus ou de la sélectionner et d'appuyer sur le
bouton «Ajouter». Une fois toutes les interfaces ajoutées,
il suffit de cliquer sur le bouton «Ok».
Toutes les méthodes définies dans la ou les interfaces
sélectionnées seront présentes dans le code source de la
classe générée.
Si le package saisi n'existe pas dans le projet,
celui ci sera créé en même temps que la classe.
Une fois toutes les données utiles renseignées, il suffit
de cliquer sur « Fin » pour que la classe soit
générée et que l'éditeur s'ouvre avec le
contenu de son code source.
La création d'une interface peut se faire :
-
en cliquant sur l'icône
 dans la barre
d'outils
-
en sélectionnant l'option Interface du menu
« Fichier/Nouveau »
Un assistant facilite la création de l'interface.
L'assistant demande de renseigner les différentes
caractéristiques de la nouvelle interface : le projet
et le package d'appartenance, le nom, les
modificateurs.
Une fois toutes les données utiles renseignées, il suffit
de cliquer sur « Fin » pour que l'interface
soit générée et que l'éditeur s'ouvre avec le
contenu de son code source.
Le JDT contient les vues "Packages" et "Hiérarchie"
Cette vue permet d'afficher de façon arborescente le
contenu des différents packages définis et utilisés dans
chaque projet.
Pour les éléments contenant du code source,
l'arborescence sous jacente permet de voir les
différents membres qui composent l'élément.
Un double clic sur des éléments de l'arborescence,
permet d'ouvrir l'éditeur directement sur
l'élément sélectionné.
Chaque élément de l'arborescence possède une petite
icône en fonction en son type :
|
Icône
|
Type de l'élément
|
|
|
Projet de type Java
|
|
|
Package
|
|
|
Elément Java : classe ou interface
|
|
|
Interface Java
|
|
|
Classe public Java
|
|
|
Classe Java pouvant être exécutée (possédant une
méthode main())
|
|
|
Classe protected
|
|
|
Classe package friendly
|
|
|
Classe private
|
|
|
Champ public
|
|
|
Champ private
|
|
|
Champ protected
|
|
|
Champ package friendly
|
|
|
Méthode public
|
|
|
Méthode private
|
|
|
Méthode protected
|
|
|
Méthode package friendly
|
Le bouton  permet de masquer les champs
définis dans les éléments java.
Le bouton  permet de masquer les membres
statiques.
Le bouton  permet de masquer tous les
membres qui ne sont pas publics.
Il est possible de restreindre les entités affichées dans
la vue package. Il suffit de cliquer sur bouton 
et de sélectionner l'option
« Filtres ».
Il suffit de cocher les filtres qui doivent être appliqués.
A partir de l'éditeur, il est possible de
sélectionner dans la vue "Package", l'élément en
cours d'édition en utilisant l'option "Afficher
dans la vue package" du menu contextuel.
6.3.2. La vue
"Hiérarchie"
Cette vue affiche la hiérarchie d'un élément.
Pour afficher la hiérarchie d'un élément, il y a
plusieurs possibilités :
-
dans la vue Package sélectionner l'élément et
d'utiliser l'option "Ouvrir la hiérarchie des
types" du menu contextuel.
-
dans l'éditeur, utiliser le menu contextuel "Ouvrir
la hiérarchie des types"
Elle se compose de deux parties :
-
une partie supérieure qui affiche la hiérarchie de
l'élément.
-
une partie inférieure qui affiche la liste de membres de
l'élément
Le bouton  permet de sélectionner
dans un historique un élément qui a déjà été affiché dans
la vue.
Il suffit de sélectionner l'élément concerné et de
cliquer sur "OK".
Le bouton  permet d'afficher
la hiérarchie des classes mères et des interfaces
qu'elles implémentent de l'élément courant.
Le bouton menu permet de changer la présentation de la
vue :
-
: les deux parties sont affichées horizontalement
-
: les deux parties sont affichées verticalement
-
: n'affiche que la partie qui présente la
hiérarchie
Le bouton  permet de masquer les champs
Le bouton  permet de masquer les membres
statiques.
Le bouton  permet de masquer tous les
membres qui ne sont pas publics.
Le JDT propose un éditeur dédié au fichier contenant du
code java. Il propose des fonctionnalités particulièrement
pratiques pour le développement de code Java
notamment :
-
la coloration syntaxique
-
la complétion de code
-
le formatage du code source
-
l'importation et l'exportation de code via un assistant
-
une forte synergie avec le debogueur
Pour ouvrir un élément dans l'éditeur, il y a deux
façons principales :
-
double cliquer sur un élément dans la vue "Navigateur"
-
double cliquer sur un élément dans la vue "Packages"
L'éditeur peut être invoqué sur un fichier .java ou
un fichier .class. Dans le cas d'un fichier .class,
si le fichier source est disponible dans l'IDE, alors
l'éditeur affiche le contenu du code source.
6.4.1. Utilisation de
l'éditeur de code
La ligne ou se situe le curseur apparaît en gris.
De chaque côté de la zone d'édition, il y a une
colonne qui peut contenir de petites icônes pour fournir
des informations à l'utilisateur.
Par exemple, il on fait hérité une classe d'une
classe dont le package n'est pas importé, un clic sur
la petite ampoule jaune permet d'obtenir des
propositions de corrections.
Il suffit de sélectionner une des actions proposées dans la
liste pour que celle ci soit automatiquement mise en
oeuvre. Un aperçu des modifications impliquées par
l'action sélectionnée est affiché dans une bulle
d'aide.
Le bouton  de la barre
d'outils permet, s'il est sélectionné,
d'afficher une bulle d'aide contenant des
informations sur l'élément sous lequel est le
curseur.
Une description plus détaillée peut être obtenue en
position le curseur sur l'élément et en appuyant sur
F2 ou en sélectionnant l'option « Afficher une
description de type infobulles » du menu
« Editer »
6.4.2. L'éditeur et la
vue Structure
Il existe un link entre l'éditeur et la vue
«Structure». Si cette vue est visible dans la perspective,
dès que le curseur se déplace sur un membre de la classe en
cours d'édition, le membre concerné est
automatiquement sélectionné dans la vue «Structure».
Les lignes concernant le membre sélectionné sont marqués
par une partie grisée dans la colonne de gauche de
l'éditeur.
Les modifications apportées dans le code source (ajout,
modification ou suppression de membres) sont
automatiquement répercutées dans la vue "Structure".
Le bouton  de la barre
d'outils permet de limiter l'affichage dans
l'éditeur du membre sélectionné dans la vue
"Structure".
Pour réafficher le source complet, il suffit de cliquer de
nouveau sur le bouton.
6.4.3. La coloration
syntaxique
L'éditeur possède une fonction de coloration
syntaxique. Par défaut, les éléments suivants sont colorés
de la façon suivante :
-
les mots clés mots du langage sont colorés en violet gras
-
les chaînes de caractères sont en bleu
-
les commentaires sont en vert
-
les commentaires Javadoc sont en bleu plus clair
-
les balises Javadoc sont en gris
-
les autres éléments sont en noir
Exemple :
Il est possible de modifier ces couleurs par défaut dans
les préférences (menu Fenêtres/Préférence)
Il faut sélectionner l'élément Java/Editeur dans
l'arborescence. Cet élément possède quatre onglets.
L'onglet syntaxe permet de modifier les couleurs.
Il suffit de sélectionner l'élément concerné dans la
liste déroulante et de sélectionner la couleur qui lui est
associée en cliquant sur le bouton couleur. Une boîte de
dialogue permet de sélectionner la nouvelle couleur à
utiliser.
6.4.4. Utilisation des
modèles
Il suffit de saisir le nom du modèle et d'appuyer sur
Ctrl et espace en même temps
Exemple : avec le modèle if
Il suffit de sélectionner le modèle à insérer pour
qu'il soit immédiatement insérer dans le code.
Il est possible d'ajouter, de modifier ou de
supprimer un modèle en utilisant les préférences (menu
Fenêtre/Préférences).
Il suffit de sélectionner dans l'arborescence
"Java/Modèles"
Pour modifier un modèle, il suffit de cliquer sur "Editer"
6.4.5. La gestion des
importations
Il est possible de faire insérer la clause import pour un
élément utilisé dans le code. Pour cela, il suffit de
mettre le curseur sur l'élément concerné et de
sélectionner l'option « Source/Ajout d'une
instruction d'import » ou d'appuyer sur
les touche Ctrl + Maj + M.
Si l'élément est déclaré dans un package unique, la
clause import est automatiquement générée. Sinon une boîte
de dialogue demande de sélectionner l'élément pour
lequel la clause import sera générée.
La fonctionnalité "Organisation des importations" est
très pratique car elle permet d'insérer
automatiquement les clauses imports avec les package requis
par le code.
Par exemple : une variable de type Socket est
déclarée, sans que le package java.net ne soit importé
Pour ajouter automatiquement la clause d'importation,
il suffit d'utiliser l'option "Source/Organiser
les importations" du menu contextuel.
La clause import est insérer dans le code. Si un élément
est contenu dans plusieurs packages, une boîte de dialogue
demande la sélection du type à importer.
Cette fonctionnalité supprime aussi automatiquement les
importations qui sont inutiles.
Certains réglages de cette fonctionnalités peuvent être
effectués dans les préférences (menu
"Fenêtre/Préférences"). Il suffit de sélectionner
« Java/Organisation des importations » dans
l'arborescence.
6.4.6. La génération
de getter et setter
Il suffit d'utiliser l'option "Source/Générer
les méthodes getter et setter" du menu contextuel.
Une boîte de dialogue permet de sélectionner, pour chaque
attribut de la classe en cours d'édition, les getters
et setters à générer
Il suffit de sélectionner les méthodes nécessaires pour
qu'une génération par défaut soit effectuée dans le
code.
L'éditeur peut formater le code selon des règles
définies. Pour utiliser cette fonctionnalité, il suffit
d'utiliser l'option « Formater » du
menu contextuel.
Les règles utilisées pour formater sont définies dans les
préférences (menu "Fenêtre/Préférences").
Il faut sélectionner dans l'arborescence,
"Java/Module de formatage de code". Les règles de formatage
peuvent être définies grâce à trois onglets.
Lors de la sauvegarde, les erreurs sont signalées grâce à
plusieurs indicateurs dans différentes vues.
Les erreurs sont signalées par une îcone ronde rouge
contenant une croix blanche.
Les erreurs sont signalées dans les vues suivantes :
-
dans l'éditeur, la ou les lignes contenant une ou
plusieurs erreurs
-
dans la vue "Tâches", une entrée pour chaque erreur est
créée pour facilter leur recencement et leur accès
-
dans la vue "Packages", tous les éléments allant du
fichier source au projet, sont marqués de la petite
icône
Dans l'éditeur, le simple fait de laisser le pointeur
de la souris sur la petite icône permet d'afficher
une bulle d'aide qui précise l'erreur.
Les boutons  et  permettent
respectivement de se positionner sur l'erreur
suivante et sur l'erreur précédente.
6.5. Exécution d'une
application
Dans la vue Java, il est possible d'exécuter une
application de plusieurs façons.
Pour exécuter l'application en cours d'édition,
il suffit de cliquer sur la flèche du bouton 
de la barre d'outils.
Ce menu déroulant propose différentes options :
-
relancer les précédentes exécutions listées dans la
première partie du menu
-
l'option "Exécuter en tant que" permet de lancer
l'application dans trois modes différents
(Application java, Test JUnit et plan de travail
d'exécution)
-
l'option "Exécuter" ouvre une boîte de dialogue
pour paramétrer précisément les options d'exécution
L'option "Exécuter en tant que / Application Java"
lance la méthode main() d'une application.
L'option "Exécuter" ouvre une boîte de dialogue
qui permet de saisir tous les paramètres d'éxécution.
La boite de dialogue se compose de six onglets.
L'onglet «Main» permet de sélectionner le projet
et la classe de ce projet qui contient la méthode main() à
exécuter.
L'onglet «Arguments» permet de préciser les arguments
passés à l'application et à la machine virtuelle.
L'onglet «JRE» permet de sélectionner le JRE à
utiliser lors de l'exécution.
L'onglet «Chemin d'accès aux classes» permet de
modifier la liste et l'ordre des bibliothèques
utilisées lors de l'exécution. Cette onglets permet
de modifier la liste définie dans le projet qui est celle
utilisée par défaut.
L'onglet commun permet de préciser le type de
lancement et le mode d'exécution et de débogage.
Une fois tous les paramètres voulus renseignés, il suffit
de cliquer sur le bouton « Exécuter » pour lancer
l'application.
La vue « Console » permet de voir les données qui
sont envoyées dans le flux standard de sortie et
d'erreurs.
Les messages ayant pour origine une exception sont aussi
envoyés dans cette vue.
6.6. Génération de la
documentation javadoc
Pour demander la génération de la documentation javadoc, il
faut utiliser le menu "Projet/Générer/le javadoc".
Pour utiliser cet option, il faut obligatoirement que les
préférences concernant javadoc soit renseignées, sinon un
message d'erreur empêche l'utilisation de l'assistant
Pour résoudre le problème, il faut aller dans
l'arborescence java/javadoc des préférences, cliquer sur le
bouton "Parcourir" et sélectionner le fichier javadoc.exe
du JDK à utiliser.
Cliquer sur "OK" pour valider les modifications.
La génération de la documentation au format javadoc se fait
avec un assistant. Il faut lui indiquer : le ou les projets
concernés, la visibilité des membres à inclure, le doclet à
utiliser et le répertoire de destination.
Cliquer sur "Suivant"
La page suivante de l'assistant permet de préciser des
options pour l'outil javadoc.
Une fois les options configurées, cliquer sur "Suivant"
La page suivante de l'assistant permet de préciser d'autres
options.
en cliquant sur "Fin", la génération de la documentation
est effectuée.
L'assistant demande si l'emplacement javadoc du projet doit
être mis à jour.
Il est conseillé de répondre "Oui" pour permettre d'avoir
accès à cette documentation à partir de l'éditeur en
appuyant sur Shift F2.
Le détails de la génération est affichée dans le vue
"Console".
Copyright (C) 1999-2003 Jean Michel DOUDOUX
|
