7. Le Java Development Tooling (JDT)

Le Java Development Tooling (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 l'espace de travail, 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.

7.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.

7.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 l'espace de travail courant sinon un message d'erreur est affiché.

En cliquant sur le bouton "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 le bouton "Fin". Le projet apparait dans la vue "Packages" de la perspective.

La version 3.1 d'Eclipse propose quelques fonctionnalités intéressantes lors de la création d'un projet Java. Sélectionnez "Projet Java" et cliquez sur le bouton "Suivant". La première page de l'assistant propose des options pour faciliter la création du nouveau projet : le contenu du projet : précise si le projet est un nouveau projet ou si le projet est importé la conformité JDK : précise le JDK utilisé par le JDK disposition du projet : précise si les sources et les binaires compilés sont mélangés à la racine ou stockés dans des répertoires dédiés. A partir de cette page, il est possible de demander la création d'un projet à partir de source existantes : dans ce cas, le projet n'est pas créer physiquement dans le workspace. Pour cela, il faut cliquer sur « Créer un projet à partir d'une source existante » et cliquer sur le bouton « Parcourir ». Sélectionnez le répertoire et cliquez sur le bouton « OK » Cliquez sur le bouton « Suivant » : le projet est ajouté dans le workspace et la page suivante de l'assistant est affichée. Cliquez sur le bouton « Terminer ». Il est possible de modifier la disposition du projet après sa création en utilisant les propriétés du projet. Cocher « Permettre des dossiers de sortie pour les dossiers source » Sélectionnez dans l'arborescence « Dossier de sortie » et cliquer sur le lien « Configurer les options du dossier de sortie » Pour préciser un répertoire particulier, sélectionnez « Dossier de sortie spécifique » Saisissez ou sélectionnez le nom du répertoire et cliquez sur le bouton « OK » Cliquez sur le bouton « OK » Cliquez sur le bouton « Terminer ».

L'onglet "Source" de la page "Paramètres Java" s'est enrichi de deux options : "Lier une source supplémentaire" et "Ajouter le projet au chemin de génération".

7.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 :

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 le bouton "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 l'espace de travail 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 une nouvelle bibliothèque contenue dans l'espace de travail, il suffit de cliquer sur "Ajouter des fichiers jar". Pour ajouter des fichiers jar qui ne sont pas contenus dans l'epsace de travail, il suffit de cliquer sur le bouton "Ajouter des fichiers jar externes".

Une boite de dialogue permet de sélectionner le fichier jar. En cliquant sur le bouton "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 contenir) et de définir les ressources qui seront utilisables par les autres projets de l'espace de travail lorsque le projet sera lié avec eux.

7.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 et les interfaces.

7.2.1. La création de packages

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.

Cliquez sur le bouton "Fin", pour créer le nouveau package. Le package apparait dans la vue "Packages".

7.2.2. La création de classes

Un assistant facilite la création de la classe. Cette création d'une classe peut se faire :

• soit en cliquant sur l'îcône dans la barre d'outils
• soit en sélectionnant l'option Classe du menu " Fichier/Nouveau "

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 "Packages", 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 le bouton " Fin " pour que la classe soit générée et que l'éditeur s'ouvre avec le contenu de son code source.

7.2.3. La création d'interfaces

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 ainsi que les éventuelles interfaces héritées.

Une fois toutes les données utiles renseignées, il suffit de cliquer sur le bouton " Fin " pour que l'interface soit générée et que l'éditeur s'ouvre avec le contenu de son code source.

7.2.4. La création de classe et de package par copier/coller du code source dans l'explorateur de package

Cette fonctionnalité permet de créer une classe et éventuellement le package associé en copiant le code source de la classe à partir du contenu du presse papier (par exemple remplie par la copie du code à partir d'un éditeur externe) et en collant le contenu sur un projet de l'explorateur de package (Ctrl+V ou option « coller » du menu contextuel). Exemple : package fr.jmdoudoux.test.cetc; public class Test {   public static void main(String[] args) {     System.out.println("test");   } }   La classe et le package sont automatiquement créés. Attention : pour que la création du package puisse être réalisé, il faut absolument que le coller se fasse sur un projet.

7.3. Le support de Java 5.0

Eclipse 3.1 propose un support complet de Java 5.0. La version de Java à utiliser dans un projet peut être précisée lors de la création d'un projet : Par défaut, c'est la version 1.4 qui sera utilisée par défaut. Pour préciser une version différente, il suffit de cocher « Utiliser une compatibilité propre au projet » et de sélectionner la version à utiliser dans la liste déroulante. Il est possible de modifier la version du JDK à utiliser dans les préférences du projet. Il suffit de sélectionner « Compilateur Java » dans l'arborescence et de sélectionner la version du JDK à utiliser. Cliquez sur « Oui » pour recompiler l'intégralité du projet avec la nouveau JDK.

7.3.1. La création d'une énumération

Il est possible de créer une énumération en demandant la création d'une entité de type « Java/Enumération ». Il faut saisir le nom du package et le nom de la classe. Si le projet n'est pas configuré pour utiliser le JDK 5.0, un message d'erreur est affiché En cliquant le bouton « Terminer », la classe est générée : Exemple : package com.jmd.test; public enum MonStyle { } Il suffit alors de compléter la classe avec les différentes valeurs qui composent l'énumération Exemple : package com.jmd.test; public enum MonStyle {   STYLE_1, STYLE2, STYLE_3 }

7.3.2. La création d'une annotation

Il est possible de créer une annotation en demandant la création d'une entité de type « Java/Annotation ». Si le projet n'est pas configuré pour utiliser le JDK 5.0, un message d'erreur est affiché.

7.4. Le support de Java 6.0 par le compilateur

Dans les propriétés du projet, il est possible de préciser dans « Compilateur Java » le support de Java 6.0. Pour modifier la version de Java, cochez la case « Activer les paramètres propres au projet » Sélectionnez la version 6.0 dans la liste déroulante. Cliquez sur le bouton « Oui » pour recompiler tous les fichiers sources avec une cible ( target ) 1.6. Remarque : pour que cela fonctionne correctement, il est nécessaire qu'un JDK 6.0 soit installé sur la machine et configuré dans Eclipse.

7.5. Les vues du JDT

Le JDT contient les vues "Packages" et "Hiérarchie"

7.5.1. La vue "Packages"

Cette vue permet d'afficher de façon arborescente le contenu des différents packages définis et utilisés dans chaque projet ainsi que les bibliothèques utilisées par le 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 :

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.

Par défaut, toutes les entités contenant du code source Java sont présentées avec la même icône. Il est possible de demander l'utilisation d'une icône dédiée pour les interfaces, les classes abstraites, les annotations et les énumérations en utilisant les Préférences. Dans l'arborescence « Général / Apparence / Décorations d'intitulés », il suffit de cocher « Indicateur de type Java » et de cliquer sur le bouton « OK ».

7.5.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 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 des 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 le bouton "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.

7.5.3. La vue "Javadoc"

La vue "Javadoc" permet d'afficher la documentation de l'élément sélectionné dans la perspective "Java".

7.5.4. La vue "Déclaration"

La vue "Déclaration" permet d'afficher le code de l'élément sélectionné dans la perspective "Java".

7.5.5. La vue Erreurs

Cette vue les erreurs et en particulier celles concernant les erreurs dans le code source des classes Java.

Pour afficher cette vue, il utiliser le menu principal « Fenêtre / Afficher la vue / Autre ...  »

Sélectionnez « Tâches de base / Erreurs » dans l'arborescence et cliquez sur le bouton « OK »

Il est possible d'ouvrir l'éditeur directement sur la ligne concernée par l'erreur en double cliquant sur l'erreur concernée.

Il est possible  d'appliquer des filtres sur cette vue qui par défaut s'applique à tout le plan de travail.

Le filtre peut limiter l'affichage des erreurs concernant un type, un ensemble de ressources, contenant tout ou partie d'une description et le niveau de gravité des erreurs.

Le tri peut se faire sur quatre critères parmi ceux proposés en précisant pour chaque le sens de l'ordre de tri.

Pour appliquer le tri, il suffit de cliquer sur le bouton « OK ».

La vue affiche les différentes erreurs regroupées par type. Le bouton  permet de gérer les filtres Cliquez sur le bouton « Nouveau » Saisissez le nom du filtre et cliquez sur le bouton « OK » Saisissez les caractéristiques du filtre et cliquez sur le bouton « OK » Le bouton  affiche le menu déroulant : le filtre créé peut être sélectionné dans le sous menu filtres Le menu « Regrouper par » permet de sélectionner le type de regroupement Exemple avec un regroupement par gravité Exemple avec un regroupement par Type Exemple avec un regroupement par type d'erreur Java L'option « Préférences » du menu permet de modifier les paramètres

7.5.6. La vue Historique

La vue Historique affiche ensemble les différentes versions des éléments de l'historique local et éventuellement du système de gestion de version connectés au projet. Pour l'afficher, il faut utiliser l'option « afficher la vue / autres » du menu principal fenêtre. Il faut sélectionner l'élément « Historique » dans « Equipe ».

7.6. L'éditeur de code

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 débogueur

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.

7.6.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, si l'on fait hériter 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 positionnant le curseur sur l'élément et en appuyant sur la touche F2 ou en sélectionnant l'option " Afficher une description de type infobulles" du menu " Editer ".

Les méthodes héritées qui sont réécrites sont signalées par une petite icône. Un clic sur cette petite icône permet d'ouvrir l'éditeur sur la méthode de la classe mère.

7.6.2. Complétion de code

La complétion de code permet de demander à l'IDE de proposer des suggestions pour terminer le morceau de code en cours d'écriture. Dans l'éditeur Eclipse, pour l'activer, il suffit d'appuyer sur les touches Ctrl et espace en même temps.

Cette fonction peut être appelée alors qu'aucune ou une partie du code à compléter est saisie.

La complétion de code s'adapte au contexte dans lequel elle est appelée. Par exemple, elle peut être appelée pour compléter une clause d'importation. Dans ce cas, elle propose une liste de packages en tenant compte du code déjà saisi.

L'éditeur peut générer la structure d'un commentaire Javadoc dans le source. Par exemple, avant une méthode, il suffit de saisir /** puis d'appuyer sur la touche " Entrée ".

L'appel de la complétion de code en appuyant sur les touches Ctrl + Espace permet aussi de faciliter la saisie des commentaires de type Javadoc.

La complétion de code permet de générer une classe interne à partir d'une interface.

Après la saisie de la parenthèse ouvrante, il suffit d'appuyer sur les touches Ctrl + Espace. L'éditeur va générer la classe interne qui implémente l'interface.

Il suffit de rajouter le ; à la fin de la déclaration de la classe interne et mettre le code nécessaire à la place du commentaire représentant une tâche à faire.

La complétion de code permet aussi de définir des méthodes définies dans une interface implémentée dans la classe ou de redéfinir une méthode héritée.

Dans le code du corps de la classe, il suffit d'appuyer directement sur les touches Ctrl + Espace. L'éditeur propose la liste des méthodes à implémenter ou à rédéfinir en fonction de la déclaration de la classe.

La signature de la méthode sélectionnée est généré dans le code.

Par défaut, dans le cas de la redéfinition d'une méthode, l'appel à la méthode correspondante de la classe mère est appelée.

Il est possible d'invoquer l'assistant de code en saisissant uniquement les premières lettres capitalisées de l'entité désirée Exemple : Cette possibilité peut être désactivée en décocher la case « Afficher les correspondances avec majuscules et minuscules » dans les préférences « Java/Editeur/Affiche l'assistant de contenu ».   L'appel de l'assistant de contenu affiche les propositions regroupées par catégories. Exemple : saisir do dans l'éditeur de code Java et appuyer sur Ctrl+espace un second appui sur Ctrl+espace affiche une autre catégorie de propositions Le mode de fonctionnement peut être configuré dans les préférences

7.6.3. Affichage des paramètres sous la forme d'une bulle d'aide

Il est quasiment impossible de retenir les arguments nécessaires à toutes les méthodes de toutes les classes utilisées. L'éditeur d'Eclipse propose d'afficher sous la forme d'une bulle d'aide, les paramètres avec leur type pour la méthode en cours de rédaction dans le code.

Pour utiliser cette fonction, il suffit d'appuyer sur les touches Ctrl + Maj + Espace en même temps dans l'éditeur pendant la saisie d'un ou des paramètres d'une méthode.

Si la méthode est surchargée, alors Eclipse demande de choisir la méthode à utiliser pour ainsi déterminer avec précision les paramètres à afficher dans la bulle d'aide.

7.6.4. Hiérarchie de type dans une bulle d'aide

Il est possible demander dans l'éditeur de code d'afficher une bulle d'aide contenant la hiérarchie d'un type. Pour cela, il suffit de mettre le curseur sur un type, une méthode ou un package et d'appuyer sur la combinaison de touches Ctrl+T.

7.6.5. Affichage des membres dans une bulle d'aide

Il est possible demander dans l'éditeur de code d'afficher une bulle d'aide contenant la liste des membres d'un type. Pour cela, il suffit de mettre le curseur sur un type ou une méthode et d'appuyer sur la combinaison de touches Ctrl+F3. Il est possible de filtrer les éléments en saisissant les premiers caractères des membres à afficher :

7.6.6. L'éditeur et la vue Structure

Il existe un lien 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.

7.6.7. La coloration syntaxique

L'éditeur possède une fonction de coloration syntaxique. Par défaut, les éléments 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.

7.6.8. Utilisation des modèles

Il suffit de saisir le nom du modèle et d'appuyer sur les touches Ctrl + 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 le bouton "Editer"

7.6.9. 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 touches 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érée 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 car aucune classe incluse dans ces packages n'est utilisée dans le code.

Certains réglages de cette fonctionnalité 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.

Les importations sont mises à jour lors d'un copier/coller d'une portion de code source. Cette nouvelle fonctionnalité très pratique permet lors d'un copier/coller d'un morceau de code d'une classe dans une autre de mettre à jour les importations requises. Attention : cette fonctionnalité ne s'applique que si le copier et le coller est fait dans Eclipse.

7.6.10. Le tri des membres

Cette fonctionnalité est accessible en utilisant l'option « Source / Trier les membres ... » du menu contextuel de l'éditeur de code Java. Cette boîte de dialogue permet de sélectionner les membres impactés par le tri. Cliquez sur le bouton « OK » pour demander le tri des membres du code source. Cliquez sur le bouton « OK » après  avoir pris connaissance du message d'avertissement. Le lien « Ordre de tri des membres » permet d'ouvrir les préférences sur l'arborescence « Java / Apparence / Ordre de tri des membres ... ». Pour modifier l'ordre des membres dans le tri, il suffit de sélection le type de membres concernés et d'utiliser les boutons « Haut » et « Bas ». La case à cocher « Trier les membres d'une même catégorie par visibilité » est assez explicite : pour l'activer il suffit de la cocher et de modifier au besoin l'ordre des modificateurs d'accès. Cliquez sur le bouton « OK » pour valider les modifications.

7.6.11. 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.

Il est possible de créer directement des méthodes de type getter/setter ou le constructeur par défaut en utilisant la combinaison Ctrl+espace dans le corps d'une classe Exemple : demander la création d'un setter pour le champ chaîne.

7.6.12. La génération des méthodes hashCode() et equals()

Il est possible de demander la génération des méthodes hashCode ( ) et equals () en utilisant, dans l'éditeur de code, l'option « Source / Générer hashCode() et equals() » du menu contextuel. Exemple : public class Personne {   private String nom;   private String Prenom; } Une boîte de dialogue permet de sélectionner les champs qui vont être utilisés dans le corps de ces méthodes. Par défaut tous les champs de classe sont sélectionnés. Cliquez sur le bouton « OK » une fois la sélection effectuée. Le code de la classe est enrichi des deux méthodes : Exemple : /* (non-Javadoc)  * @see java.lang.Object#hashCode()  */ @Override public int hashCode() {   final int PRIME = 31;   int result = 1;   result = PRIME * result + ((Prenom == null) ? 0 : Prenom.hashCode());   result = PRIME * result + ((nom == null) ? 0 : nom.hashCode());   return result; } /* (non-Javadoc)  * @see java.lang.Object#equals(java.lang.Object)  */ @Override public boolean equals(Object obj) {   if (this == obj)     return true;   if (obj == null)     return false;   if (getClass() != obj.getClass())     return false;   final Personne other = (Personne) obj;   if (Prenom == null) {     if (other.Prenom != null)       return false;   } else if (!Prenom.equals(other.Prenom))     return false;   if (nom == null) {     if (other.nom != null)       return false;   } else if (!nom.equals(other.nom))     return false;   return true; }

7.6.13. Formater 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.

Le module de formatage de code a été entière réécrit et propose plusieurs fonctionnalités intéressantes : il propose deux profils prédéfinis (convention java et Eclipse 2.1) non modifiable sans duplication il permet de créer son propre profil il propose un aperçu du style sélectionné échanger des profiles entre plusieurs installations d'Eclipse 3 par import/export Les préférences permettent de mettre en oeuvre ces nouvelles fonctionnalités. Le bouton « Afficher » permet de voir les différents options qui composent le profil. Le bouton « Créer » permet de créer son propre style à partir d'un style existant. Il faut saisir le nom, sélectionner le profil d'origine et cliquer sur le bouton « OK ». La configuration des paramètres du profil est particulièrement riche et permet un niveau de détails très important. Dans la perspective Java, il est possible de demander le formatage du code source de tous les fichiers d'un package ou d'un projet en utilisant l'option « Source / Formater » du menu contextuel des éléments. Une boite de dialogue demande la confirmation car l'opération ne peut être annulée.

7.6.14. Mise en commentaire d'une portion de code

L'éditeur permet de mettre en commentaire une portion de code. Il suffit de sélectionner la portion de code concernée.

Puis, il faut utiliser l'option " Source / Mettre en commentaires " du menu contextuel de l'éditeur.

Pour supprimer les commentaires sur une portion de code, il suffit de sélectionner la portion de code et d'utiliser l'option " Source / Supprimer la mise en commentaire " du menu contextuel.

Les options de menu « Source / Mettre en commentaire » et « Source / Supprimer les commentaires » sont remplacées par une unique option « Source / Ajout/suppression de la mise en commentaires » qui effectue l'opération en fonction du contexte. L'option « Source / Mettre en commentaire un bloc » du menu contextuel permet de mettre en commentaire la portion de code sélectionner grâce à un commentaire de type multi-ligne. Exemple Résultat : Pour utiliser cette fonctionnalité, il est aussi possible d'utiliser la combinaison de touches Ctrl+Maj+/ L'option « Source / Supprimer ma mise en commentaire un bloc » permet l'opération inverse.

7.6.15. Protéger une portion de code avec un bloc try/catch

L'éditeur propose une option qui permet automatiquement de rechercher, dans un bloc de code sélectionné, une ou plusieurs exceptions pouvant être levées et de protéger le bloc de code avec une instruction de type try / catch.

Il faut sélectionner le bloc de code à protéger.

Puis utiliser l'option " Source / Entourer d'un bloc try / catch ". L'éditeur analyse le code et génère la cause try / catch qui va capturer toutes les exceptions qui peuvent être levées dans le bloc de code sélectionné.

Chacune des instructions catch est marquée avec une tache " bloc catch auto-généré " pour indiquer au développeur d'ajouter le code nécessaire au traitement de l'exception.

Si le bloc de code ne contient aucun appel de méthode susceptible de lever une exception, une boîte de dialogue demande si l'instruction catch doit capturer une exception de type RuntimeException.

7.6.16. La fonctionnalité « Entourer avec »

Dans l'éditeur de code Java, il est possible facilement d'entourer une portion de code grâce à la fonctionnalité « Entourer avec ». Pour cela, sélectionnez une portion de code dans l'éditeur Puis utilisez l'option « Entourer avec » du menu contextuel. Son sous menu propose plusieurs modèles par défaut. Sélectionnez par exemple « 3 if (instruction if) » Il est possible d'accéder directement au sous menu en utilisant la combinaison de touches shift+ alt +z Les modèles sont extensibles : pour gérer les modèles, il faut  utiliser l'option « Configurer les modèles » du menu contextuel ou ouvrir les préférences et sélectionner « Java / Editeur / Modèles » dans l'arborescence. Les boutons « Importer » et « Exporter » permettent d'importer et d'exporter les modèles. Pour exporter un ou plusieurs modèles, il est nécessaire de les sélectionner au préalable dans la liste afin de pouvoir rendre actif le bouton. Une boite de dialogue permet de sélectionner ou de saisir le fichier qui va contenir les données exportées au format xml . Le bouton « Importer » permet d'importer des modèles sauvegardés dans un fichier xml  : il suffit de sélectionner le fichier. Le bouton « Nouveau » permet de créer un nouveau modèle. La boîte de dialogue permet de saisir le nom du modèle, une description et le schéma, de sélectionner le contexte et de préciser si l'insertion peut être automatique. Les modèles existants peuvent être d'une grande aide pour faciliter la compréhension de la rédaction du schéma. Le bouton « Insérer une variable » permet d'insérer une variable prédéfinie. Une fois toutes les données saisies, cliquez sur le bouton « OK » pour créer le nouveau modèle.

7.6.17. Les avertissements

7.6.17.1. Détection de l'assignation d'une valeur à un paramètre

Il est possible de demander au compilateur de signaler les assignements d'une valeur à un paramètre d'une méthode. Par défaut, le compilateur ignore ces actions. Pour les activer, il faut préciser « Avertissement » ou « Erreur » à l'option « Style du code / Affectation de paramètres »  dans « Compilateur Java / Erreur avertissements » dans les propriétés du projet.

7.6.17.2. Détection d'un oubli potentiel de l'instruction break

Il est possible de demander au compilateur de signaler les oublis potentiels de l'instruction break dans les cases de l'instruction switch. Par défaut, le compilateur ignore ces actions. Pour les activer, il faut préciser « Avertissement » ou « Erreur » à l'option « Erreurs de programmation possibles / Saut au bloc case suivant »  dans « Compilateur Java / Erreur avertissements » dans les propriétés du projet.  Le quick fixe propose d'ajouter l'instruction break manquante.

7.6.18. Les erreurs

Lors de la sauvegarde du fichier, celui ci est compilé et les erreurs trouvées 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 dans les vues suivantes :

• dans l'éditeur, la ou les lignes contenant une ou plusieurs erreurs sont marquées avec cette icône
• dans la vue "Tâches", une entrée pour chaque erreur est créée pour faciliter 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.

Ces mécanismes sont aussi utilisables au cours de la saisie du code Java dans l'éditeur. Eclipse est capable de détecter un certain nombre d'erreurs et de les signaler.

En positionnant le curseur sur la partie de code soulignée en rouge, une bulle d'aide fournie des informations sur l'erreur.

Un clic sur la petite icône en forme d'ampoule jaune, permet d'ouvrir une fenêtre qui propose des solutions de corrections

La seconde fenêtre permet de pré-visualiser les modifications qui seront apportées par la proposition choisie.

La vue erreurs contient aussi les erreurs de compilation du code

Jusqu'à Eclipse 3.1 inclus, la détection d'une erreur empêchait la détection des erreurs suivantes. La détection des erreurs a été améliorée dans version 3.2 d'Eclipse : le même code avec Eclipse 3.2 signale d'autres erreurs.

7.6.19. Masquer certaines portions de code

L'éditeur de code Java propose de masquer certaines portions de code correspondant : aux instructions d'importation aux commentaires aux corps des méthodes La définition de ces zones est automatique. Le début d'une zone non masquée est signalée par une petit icône dans la barre de gauche de l'éditeur Pour masquer la zone, il suffit de cliquer sur le petit icône . La zone est masquée et l'icône change d'apparence : En laissant le curseur de la souris sur l'icône , une bulle d'aide affiche le contenu de la zone masquée. Les paramètres de cette fonctionnalité peuvent être modifiés dans les préférences.

7.6.20. Le mode « Insertion Avancée »

Ce mode activé par défaut permet de simplifier la tâche du développeur lors de l'insertion d'une portion de texte dans l'éditeur de code Java. Il permet notamment de fermer automatiquement les parenthèses, les accolades, les guillemets, ... Le mode de fonctionnement est signalé dans la barre d'état : . Pour basculer du mode normal au mode avancé, il suffit d'utiliser la combinaison de touche Ctrl+Maj+Ins Le paramétrage de ce mode ce fait dans les préférences.

7.6.21. Marquer les occurrences trouvées

Suite à une recherche, il est possible de demander à l'éditeur de marquer les occurrences trouvées dans le code source en activant le bouton de la barre d'outils ou en utilisant la combinaison de touche Alt+Maj+O. Les occurrences sont marquées sous la forme d'annotations. Il est possible d'utiliser les boutons et pour se positionner sur l'occurrence suivante ou précédente. Il faut cependant que les annotations de type occurrences soient cochées dans le menu déroulant associé aux boutons.

7.6.22. Marquer les points de sortie d'une méthode

Même si cela n'est pas recommandé, il est possible de mettre plusieurs instruction return dans une méthode. L'éditeur propose une fonctionnalité pour marquer sous forme d'annotation les points de sortie d'une méthode. Pour cela, il faut positionner le curseur sur le type de retour de la méthode et activer les boutons .

7.6.23. Marquer les emplacements ou une exception est levée

L'éditeur propose une fonctionnalité qui permet de marquer les méthodes qui lèvent une exception d'un type déclaré dans la signature de la méthode. Pour cela, il faut placer le curseur sur une des exceptions utilisées dans la clause throws de la déclaration de la méthode et d'utiliser l'option "Rechercher / Occurrences d'exceptions"  du menu principal.

7.6.24. L'assistant de correction rapide

L'éditeur peut faciliter la rédaction du code en proposant un certains nombre d'action selon le contexte. Pour savoir si une ou plusieurs correction rapide peuvent être proposée, il faut activer l'option dans les préférences, sous l'arborescence « Java / Editeur », sur l'onglet « Aspect », il faut cocher l'option « Activer l'ampoule pour l'assistant rapide » qui par défaut est décochée. Il suffit alors de cliquer sur l'ampoule ou d'utiliser la combinaison de touche Ctrl+1 pour activer l'assistant. Les opérations proposées par l'assistant le sont fonction du contexte. Les différentes opérations proposées sont nombreuses et facilitent souvent la réalisation de petites tâches fastidieuses à réaliser manuellement, par exemple : ajouter un bloc else à une instruction if supprimer une instruction englobante modifier l'appel ou la méthode en cas de non concordance de paramètres créer un nouveau champ qui sera initialisé avec un paramètre de la méthode renommer localement un membre

Un quick fixe permet d'utiliser les generics à une collection utilisée avec le type brut.

7.6.25. La génération de constructeur

L'option « Source / générer le constructeur à partir des zones ... » du menu contextuel permet de faciliter la création d'un constructeur. Il est alors possible de sélectionner les paramètres du nouveau constructeur et les différentes options pour que le code du constructeur soit généré.

7.6.26. Raccourci clavier pour avoir accès aux fonctions de modification du code source

L'éditeur propose un menu contextuel pour accéder rapidement aux fonctions de modification du code source en utilisant la combinaison de touche Alt+Maj+S

7.6.27. Les raccourcis clavier des éditeurs

Dans un éditeur, il suffit d'utiliser la combinaison de touches Ctrl+Shift+L pour obtenir une liste des raccourcis clavier utilisable dans l'éditeur. Il suffit de réutiliser la combinaison de touche « Ctrl+Maj+L » pour afficher les préférences concernant les raccourcis clavier des éditeurs.

7.6.28. La gestion des modèles de commentaires

Dans l'éditeur de code source Java, l'option « Sources / Ajouter commentaires » (Alt + Shift + J) du menu contextuel permet d'insérer un commentaire selon un modèle prédéfini.

Ce modèle peut être paramètré dans les préférences.

Il est possible de demander la génération de commentaires sur plusieurs entités en même temps en sélectionnant dans « l'explorateur de packages » et en utilisant l'option « Source / Ajouter commentaires ».

Les modèles de commentaires sont paramétrables dans les Préférences :

Pour modifier un modèle, il faut le sélectionner dans la liste et cliquer sur le bouton « Editer ... »

Pour insérer une variable, il suffit de cliquer sur le bouton « Insérer une variable ... » ou utiliser la combinaison de touche Ctrl+Espace.

Le contenu de la plupart des variables sera déterminé dynamiquement lors de la génération du commentaire.

Une fois la saisie terminée, il faut cliquer sur le bouton « OK » pour valider les modifications.

Le modèle sélectionné ou tous les modèles peuvent être exporté et importé grâce aux boutons dédiés.

7.6.29. Le support du tag @category

Le tag Javadoc @category est supporté et intégré à Eclipse : se tag permet de regrouper des membres par catégories. L'assistant de complétion de code propose ce tag. Exemple :   /**    * @return entier    * @category getter    */   public static int getEntier() {     return entier;   }   /**    * @param entier entier à définir    * @category setter    */   public static void setEntier(int entier) {     Test.entier = entier;   } Ce tag, une fois utilisé, est exploité dans plusieurs vues d'Eclipse. La vue structure affiche la catégorie d'un membre entre crochet. Elle permet d'appliquer un filtre d'affichage sur les membres à partir de leur catégorie en cliquant sur le bouton Il est possible de cocher les catégories dont les membres seront affichés. L'option « Catégories visibles » permet de réaliser la même opération mais dans une boîte de dialogue. Celle-ci est particulièrement utile si le nombre de catégories est important. Cochez les catégories qui doivent être affichées dans la vue et cliquez sur le bouton « OK ». La vue « Membres » offre les même fonctionnalités

7.7. Exécution d'une application

Dans la perspective "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'exé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. Cet onglet 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.

L'ergonomie de la boite de dialogue « Exécuter » a été légèrement revue. La gestion des configurations se fait via de petit bouton avec des icônes. Il est possible de préciser dans les variables une variable d'Eclipse. Il est possible de la saisir directement ou d'utiliser l'assistant de sélection de variable en cliquant que le bouton « Variable ». Il suffit de sélectionner la variable en s'aidant éventuellement du filtre et de saisir l'argument Cliquez sur le bouton « OK » Exemple : source de la classe de test package fr.jmdoudoux.testb; public class TestErreurs {   public static void TestA(String valeur) {     System.out.println("valeur="+valeur);   }   public static void main(String[] argv) {     TestA(argv[0]);   } } Résultat de l'exécution : valeur= C:\java\eclipse32

7.8. 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.

Cliquez sur le bouton "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.

Cliquez sur le bouton "Suivant"

La page suivante de l'assistant permet de préciser des options pour l'outil Javadoc.

Une fois les options configurées, cliquez sur le bouton "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 les touches "Shift" + "F2".

Le détail de la génération est affiché dans le vue "Console".

Les fichiers apparaissent dans la vue "Navigateur".

7.9. Définition du JRE à utiliser

Eclipse est capable de travailler avec plusieurs JRE. Dans l'arborescence " Java/JRE installé " des préférences, il est possible de définir plusieurs JRE installés sur la machine.

Un clic sur le bouton "Editer" permet de modifier les données du JRE défini dans Eclipse.

7.10. Les environnements d'exécution

Dans les préférences, il est possible de définir pour un environnement d'exécution le JRE compatibles à utiliser. Pour chaque environnement, la liste des JRE compatibles est affichée. Les JRE affichés en gras avec la mention « [correspondance parfaite] » indique une parfaite adéquation avec l'environnement d'exécution. Il est aussi possible qu'aucun JRE compatible ne corresponde à l'environnement d'exécution. Pour définir le JRE par défaut de l'environnement d'exécution, il suffit de le cocher. L'utilisation d'un environnement d'exécution est plus souple que d'utiliser directement un JRE. Il est ainsi possible de préciser un environnement d'exécution dans une configuration d'exécution Il suffit dans l'onglet « JRE » de cocher le choix « Environnement d'exécution » et de sélectionner dans la liste l'environnement souhaité. Le bouton « Environnements ... » ouvrir directement les préférences des environnements d'exécution. Les environnements d'exécution sont aussi utilisables dans les options de « chemin de génération Java » du projet. Dans les propriétés du projet, dans l'onglet « Bibliothèque » de l'option « Chemin de génération Java », sélectionnez « Bibliothèque système JRE » et cliquez sur le bouton « Editer ...». La boîte de dialogue permet de sélectionner un environnement d'exécution. L'environnement d'exécution est précisé entre les crochets à la place du JRE.

7.11. Utilisation de l'historique local

L'historique local est une fonctionnalité proposée par Eclipse pour conserver un certain nombre de versions du code pour chaque élément contenu dans l'espace de travail.

Pour pouvoir utiliser l'historique local, il faut placer le curseur sur un élément de code sinon un message d'erreur est affiché :

L'option "Historique local" du menu contextuel propose 4 options :

• " Comparer à ... "

  

  Cette option permet de comparer la version contenue dans l'éditeur avec celles contenues dans l'historique. Il n'est pas possible de reporter les modifications avec cette option.

• " Remplacer par l'élément précédent "
  
  Cette option permet de remplacer la version de l'éditeur par la dernière contenue dans l'historique : elle correspond à la dernière sauvegarde.
  
• " Remplacer par ... "

  

  Il suffit de sélectionner la version désirée et de cliquer sur le bouton "Remplacer".

• " Restaurer à partir de ... "

  Cette option permet de restaurer des éléments contenus dans l'historique mais qui ne sont plus présents dans l'éditeur de code.

  

  Il suffit de cocher le ou les éléments et de sélectionner la version de l'historique à restaurer et de cliquer sur le bouton "Restaurer".

7.12. Externaliser les chaînes

Eclipse possède une fonction permettant d'automatiser l'externalisation des chaînes de caractères dans un fichier de ressource afin de faciliter l'internationalisation de la classe traitée.

L'exemple de cette section utilise le code source suivant :

Dans la vue "Package", il faut sélectionner le fichier source puis utiliser l'option " Source / Externaliser les chaînes " du menu contextuel.

Eclipse analyse le code source à la cherche de chaînes de caractères et affiche l'assistant " Externalisation des chaînes ".

La première page de l'assistant permet de sélectionner les chaînes de caractères à traiter détectées par Eclipse.

Pour chaque chaîne, il est possible de changer le nom de la clé associée à la chaîne de caractères et de préciser si la chaîne doit être traitée ou non.

Pour modifier la clé, il est possible de cliquer sur la clé et de saisir le nouveau nom ou de sélectionner la ligne de la chaîne et de cliquer sur le bouton " Editer la clé "

Pour indiquer si la chaîne doit être traitée, il est possible de cliquer plusieurs fois sur la case à cocher de la ligne correspondante pour obtenir le symbole correspondant à la valeur voulue ou de cliquer sur le bouton " Convertir ", " Jamais convertir " ou " Ignorer " après avoir sélectionné la ligne désirée.

Un clic sur le bouton " Suivant " permet de préciser des informations sur le fichier de ressource qui sera généré.

Un clic sur le bouton " Suivant " affiche une liste des problèmes détectés.

Un clic sur le bouton " Suivant " permet d'afficher une page qui prévisualise les modifications qui vont être apportées.

Il est possible de sélectionner tout ou partie des modifications en les cochant.

Un clic sur le bouton "Fin" met en oeuvre les modifications.

7.12.1. Rechercher les chaînes externalisées erronées

Cette fonctionnalité permet de rechercher des clés dans un fichier de ressource qui ne soient pas utilisées ou qui sont en double. Exemple : public static void main(String[] args) {   // TODO Raccord de méthode auto-généré   System.out.println(Messages.getString("chaine0")); //$NON-NLS-1$   System.out.println("chaine 2"); //$NON-NLS-1$   System.out.println(Messages.getString("chaine2")); //$NON-NLS-1$   System.out.println("chaine 4"); } Pour utiliser cette fonctionnalité, il faut sélectionner préalablement un fichier de ressource, un package ou un projet et utiliser l'option « Source / rechercher les chaînes externalisées qui ne fonctionnent pas ». Il est nécessaire qu'un moins un fichier de ressource soit présent dans la sélection sinon un message est affiché. Exemple de fichier message.properties : chaine0=chaine 1 chaine1=chaine 2 chaine2=chaine 3 chaine1=chaine 4 L'exécution de cette fonctionnalité sur l'exemple affiche le résultat suivant : Un double clic sur un des résultats de rechercher permet d'ouvrir le fichier de ressources en sélectionnant la première clé concernée par le problème.

7.12.2. Recherche de l'utilisation d'une clé

Il est possible de trouver dans le code où est utilisée une clé. Pour cela, il faut ouvrir le fichier de ressource, positionner le curseur de la souris sur la clé en maintenant la touche Ctrl enfoncée (un hyperlien s'affiche sous la clé) Il suffit alors de cliquer sur le bouton gauche de la source pour qu'Eclipse recherche les utilisations. Si la clé n'est utilisée qu'une seule fois alors la classe concernée s'ouvre dans l'éditeur ou la clé est utilisée. Si la clé est utilisée dans plusieurs classes, une boîte de dialogue permet de sélectionner celle qui doit être affichée. La zone détails affiche les lignes concernées. Il suffit de sélectionner la classe désirée et de cliquer sur le bouton « OK ».

7.13. Ouverture d'un type

Le bouton de la barre d'outils permet de lancer l'outil " Ouverture d'un type ". Cet outil est particulièrement pratique pour rechercher et ouvrir dans l'éditeur le code d'une classe dont on connaît tout ou partie du nom.

Il suffit de saisir le début du nom de la classe ou de l'interface pour que la liste des entités répondant au critère se construise de façon incrémentale.

Il est aussi possible de saisir un motif à l'aide des caractères ? pour représenter un caractère quelconque unique et * pour représenter aucun ou plusieurs caractères quelconques.

La zone qualificatif affiche le ou les packages ou l'entité est définie. Ce nom de package est suivi du nom du projet si l'entité est définie dans l'espace de travail ou du nom du fichier qui contient la version compilée pour une entité externe.

Une fois l'élément voulu sélectionné, un clic sur le bouton " OK " ouvre l'éditeur avec cette entité.

7.14. Utilisation du scrapbook

Le scrapbook, traduit par " page de testeur de code ", est une fonctionnalité qui permet de tester des morceaux de code dans une machine virtuelle. Cette fonctionnalité très intéressante était déjà présente dans l'outil Visual Age d'IBM.

Pour pouvoir l'utiliser, il faut créer une nouvelle "page de testeur de code", en utilisant une des possibilités d'Eclipse pour créer une nouvelle entité.

Comme pour la création de toute nouvelle entité, un assistant permet de recueillir les informations nécessaires à la création du scrapbook.

Une "page de testeur de code" est physiquement un fichier contenant du code java et ayant une extension .jpage

La seule page de l'assistant permet de sélectionner le répertoire qui va contenir le fichier ainsi que son nom. Par défaut, l'extension .jpage est ajoutée.

Un clic sur le bouton "Fin" permet de générer le fichier et d'ouvrir l'éditeur avec son contenu.

Le grand avantage est de pouvoir tester des morceaux de code sans avoir à créer une classe et une méthode main() et de bénéficier de fonctionnalités particulières pour tester ce code.

Exemple :

Lors de l'édition du code contenu dans le scrapbook, la barre d'outils est enrichie de plusieurs boutons qui permettent d'utiliser les principales fonctionnalités du scrapbook.

Les trois premiers boutons ne sont utilisables que si un morceau de code est sélectionné dans le scrapbook. Le quatrième bouton n'est utilisable que si une machine virtuelle exécute du code du scrapbook.

La fonction " Inspecter " permet de visualiser, dans la vue " Expressions ", les valeurs des objets contenus dans le code sélectionné.

Pour la mettre en oeuvre, il suffit de sélectionner un morceau de code dans l'éditeur du scrapbook et de cliquer sur le bouton ou d'utiliser l'option " Inspecter " du menu contextuel.

La fonction " Affichage du résultat de l'exécution " permet d'exécuter un morceau de code et d'afficher le résultat de l'exécution dans l'éditeur juste après la fin de la sélection du morceau de code.

Pour mettre en oeuvre cette fonctionnalité, il faut sélectionner un morceaux de code dans l'éditeur du scrapbook.

Il faut ensuite cliquer sur le bouton ou d'utiliser l'option " Afficher " du menu contextuel.

L'affichage insère le type entre parenthèse et la valeur du résultat dans l'éditeur.

La fonction " Exécuter " permet d'exécuter d'un morceau de code et d'afficher le résultat dans la vue " Console ". Pour mettre en oeuvre cette fonctionnalité, il faut sélectionner un morceau de code dans l'éditeur du scrapbook.

Il faut ensuite cliquer sur le bouton ou utiliser l'option " Exécuter " du menu contextuel.

Lors de l'exécution de code dans le scrapbook, une machine virtuelle dédiée est lancée pour cette exécution. Pour pouvoir relancer une exécution, il faut arrêter le machine virtuelle précédemment lancée. L'arrêt de cette machine virtuelle peut se faire en cliquant sur le bouton .

Lors de l'exécution de code dans le scrapbook, si une erreur de syntaxe est détectée, celle ci est signalée directement dans le code de l'éditeur

Exemple :

Lors de l'exécution de ce morceau de code, l'erreur suivante est affichée dans l'éditeur

La structure d'un fichier java classique n'étant pas respecter dans le scrapbook, la gestion des clauses d'import est gérée de façon particulière.

Exemple :

L'exécution de ce morceau de code génère l'erreur suivante :

Pour ajouter une clause import, il cliquer sur le bouton ou utiliser l'option " Définit les importations " du menu contextuel.

Un clic sur le bouton " Ajouter un type " permet d'importer une classe ou une interface dans le scrapbook.

.

La zone de saisie du type permet une recherche incrémentale dans toutes les entités définies dans le chemin de compilation du projet.

Un clic sur le bouton " Ajouter un Package " permet d'importer un package

La zone de saisie du package permet une recherche incrémentale du package désiré parmi tous ceux définis dans le chemin de compilation du projet.

Enfin pour supprimer l'importation d'une entité, il suffit de la sélectionner et de cliquer sur le bouton " Supprimer ".

L'assistant de code, est bien sûre disponible dans l'éditeur du scrapbook toujours en utilisant la combinaison de touches "Ctrl" + "Espace".

7.15. Le développement d'applets

Il faut créer un nouvelle classe qui hérite de la classe java.applet.Applet

La nouvelle classe est créée et l'éditeur de code ouvre son source.

Pour faciliter la réécriture des méthodes utiles, il est possible d'utiliser l'option « source / Remplacer/Implémenter les méthodes ... » du menu contextuel de l'éditeur de code.

Il suffit de cocher chaque méthode désirée et de cliquer sur le bouton « Ok ».

Le code source est enrichi avec la ou les méthodes sélectionnées :

    /* (non-Javadoc)
     * @see java.awt.Component#paint(java.awt.Graphics)
     */
    public void paint(Graphics arg0) {
      // TODO Raccord de méthode auto-généré
      super.paint(arg0); 
    }

Il suffit d'insérer le code dans ces méthodes.

Par exemple :

     /* (non-Javadoc)
      * @see java.awt.Component#paint(java.awt.Graphics)
      */
     public void paint(Graphics arg0){
       super.paint(arg0);
       arg0.drawString("Bonjour",50,50);
     }

Pour exécuter une applet, il faut utiliser l'option « Exécuter en tant que / Applet » du bouton « Exécuter » de la barre d'outils.

7.16. Le nettoyage du code

Le nettoyage du code peut s 'appliquer sur un projet, un package ou un fichier. Il suffit de sélectionner l'un de ces éléments et d'utiliser l'option « Source / Nettoyer  ... » du menu contextuel. Les fonctionnalités offertes par cet assistant sont nombreuses : la partie « Aperçu » permet d'avoir une idée sur les possibilités de chaque fonctionnalité. L'option « Utiliser les blocs dans les instructions if/ while /for/do » permet de définir le bloc contenant une instruction avec des accolades. L'option « Convertir les boucles for améliorées » permet de convertir les boucles au format Java 5.0. Le libellé de l'option « Utiliser le modificateur ‘final lorsque cela est possible' est assez explicite. Ces options permettent de modifier l'accès aux membres. Ces options permettent de supprimer certaines déclarations inutiles. Les options de l'onglet « Code manquant » permet d'ajouter les annotations manquantes définies par Java 5.0 et de générer un ID pour les classes sérialisables. Un fois les nettoyages sélectionnés, il faut cliquer sur le bouton « Suivant » Un aperçu des modifications est affiché. Chaque modification peut être validée ou non en utilisant les cases à cocher dans « Modifications à apporter » Cliquer sur le bouton « Terminer » pour exécuter les modifications.