J a c que s B APST

Technologies de l'information
et de la communication (TIC) 19 août 2005

3 .1 D ÉV ELOPPEM EN T J AV A / PREM I ERS PAS

P ROJ ET E CLI PSE

Le projet Eclipse ([Link]) a été mis sur pied dans le but de développer une plate-forme universelle
permettant d'intégrer différents outils et en particulier, des outils de développement. L'environnement de
développement Java du projet Eclipse se nomme JDT (Java Development Tooling).

Le projet Eclipse géré de manière communautaire (par un consortium nommé Eclipse Foundation auquel
participent de grandes sociétés : IBM, Borland, HP, Intel, …) propose une architecture ouverte (open-
source) et extensible qui se base sur la notion de plug-ins (briques logicielles). Eclipse est écrit en Java.

N OT I ON DE W ORK SPACE
L'environnement Eclipse utilise un espace de travail (un répertoire) appelé Workspace qui sert à
enregistrer :
les paramètres de configuration de l'environnement de développement
les méta-informations (informations sur les projets, les ressources, …)
les projets ainsi que toutes les ressources associées (fichiers sources, fichiers compilés,
documentation, fichiers jar, images, etc.).

L'emplacement du Workspace est défini lors du lancement d'Eclipse. Si l'emplacement proposé ne

correspond pas à un Workspace existant, l'infrastructure nécessaire sera automatiquement créée dans le
répertoire mentionné.
Les projets (ou une partie des ressources) peuvent également être enregistrés à l'extérieur du
Workspace mais, dans ce cas, ils seront malgré tout référencés dans le Workspace (un lien uniquement).
Il est possible de créer et de travailler avec plusieurs Workspace différents et de passer de l'un à l'autre.
La commutation n'est cependant pas instantanée et correspond pratiquement à un re-lancement
d'Eclipse.

N OT I ON S DE W ORK BEN CH / V I EW / E DI T OR / P ERSPECT I V E

L'interface utilisateur (la surface de travail) de l'environnement Eclipse est appelée Workbench.
Le Workbench est composé d'un ensemble de sous-fenêtres qui représentent soit des vues (Views) soit
des zones d'édition (Editors). Plusieurs vues et zones d'édition peuvent être empilées dans une sous-
fenêtre; dans ce cas un onglet permet de sélectionner la vue ou la zone d'édition qui doit être affichée.
Il est possible de déplacer et de redimensionner les vues et les zones d'édition (Drag&Drop du titre
respectivement des bordures de la sous-fenêtre considérée).
Le choix et la disposition des sous-fenêtres forment un arrangement appelé Perspective.
Un certain nombre de perspectives sont pré-définies (Ressource, Java, Debug, …) et l'utilisateur peut
rapidement commuter entre ces perspectives selon la tâche à effectuer (à l'aide des boutons situés dans
l'angle supérieur droit du Workbench).
Il est possible de définir ses propres perspectives, de les nommer et de les enregistrer.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 1

E SPACE DE T RAV AI L POU R LE DÉV ELOPPEM EN T J AV A ( J AV A P ERSPECT I V E )

Perspectives

Projects
Source Code
Editors
Outline View

Package
Explorer
View

Problems and
Console Views

A U T RES PERSPECT I V ES

Il existe un certain nombre de perspectives pré-définies qui permettent d'avoir plusieurs points de vues
différents d'un même projet.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 2

C RÉAT I ON D ' U N PROJ ET /

Toute écriture de code Java doit se faire dans le cadre d'un projet qu'il faut préalablement créer.
Plusieurs projets indépendants peuvent être créés dans le même Workspace.
Un projet peut contenir un nombre quelconque de ressources (classes, packages, dossiers, fichiers,
applications, …) et un certains nombre de propriétés lui sont associées (menu Project Properties).

La création d'un projet s'effectue à l'aide du menu File New Project Java Project ou en
utilisant le bouton Java Project (ou, si l'on est déjà dans la perspective Java, directement avec le
bouton de la barre d'outils).
Dans la première fenêtre de l'assistant, il suffit de mentionner le nom du projet dans le champ "Project
name:". Par défaut, le projet sera créé dans le Workspace courant (un sous-répertoire portant le nom du
projet sera créé).

Une deuxième fenêtre de l'assistant permet de définir certaines propriétés du projet (ressources
nécessaires, librairies, JRE, etc.). Pour les projets simples, il n'est pas nécessaire de modifier les valeurs
proposées, vous pouvez donc cliquer sur le bouton Finish après la première fenêtre.
Après avoir créé un projet Java, l'environnement Eclipse propose de passer (ou passe automatiquement,
selon la configuration) dans la perspective Java.
Dans la vue Package Explorer, on trouve la liste des projets référencés dans le Workspace. Les projets
peuvent être ouverts ou fermés à l'aide du menu contextuel (Open Project / Close Project). Il est
conseillé de fermer les projets sur lesquels vous ne travaillez pas car les projets ouverts consomment
des ressources et sont pris en considération lors de l'opération de compilation (Rebuild).

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 3

C RÉAT I ON D ' U N E CLASSE

La création d'une classe Java s'effectue à l'aide du menu File New Class (ou avec le bouton
de la barre d'outils).
Dans la première fenêtre de l'assistant, il suffit de mentionner le nom de la classe dans le champ
"Name:" et de spécifier éventuellement (c'est fortement recommandé) le nom du package dans le
champ "Package".

Si l'on laisse le champ Package vide, la classe sera créée dans le paquetage par défaut qui sera alors
identifié par " (default package)" dans la vue Package Explorer. Le fichier source sera créé dans le
répertoire du projet ou dans le répertoire défini dans les préférences (champ Source folder name du
menu Window Preferences Java Build Path).

Différentes options (cases à cocher) permettent de gérer les modificateurs de la classe et d'insérer du
code dans la classe (création d'une méthode main() par exemple).

En cliquant sur le bouton Finish , la classe est créée dans le projet sélectionné (on la voit apparaître
dans le Package Explorer) et le fichier source est ouvert dans une nouvelle fenêtre d'édition.
Attention : Dans l'environnement Eclipse, le nom du package détermine non seulement l'emplacement
du fichier compilé (comme l'exige le langage Java) mais également l'emplacement du fichier
source (sous-répertoire dans l'arborescence du projet).
Si l'on souhaite placer la classe dans un package, il est donc important de mentionner le
nom du package dans le fenêtre de l'assistant car, une fois le fichier source créé (sans
indication de package), on ne peut pas simplement ajouter la pseudo-instruction package
dans le code source. Il faut encore déplacer le fichier dans un répertoire portant le nom du
package.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 4

É DI T I ON D ' U N FI CH I ER SOU RCE

Pour ouvrir un fichier source dans l'éditeur il suffit de double-cliquer sur son nom dans le Package
Explorer. Plusieurs fenêtres d'édition peuvent être ouvertes simultanément (accessibles par des onglets).
L'éditeur d'Eclipse possède beaucoup de fonctionnalités permettant de simplifier l'écriture de code Java
et de nombreux aspects sont configurables (menu Window Preferences Java Editor).
Certaines erreurs sont déjà détectées durant l'édition du code source (introspection continue de tous les
fichiers sources des projets ouverts).

Agra ndir la fe nê t re d'é dit ion

Un double-clic sur l'onglet qui identifie la fenêtre d'édition permet d'agrandir cette fenêtre pour qu'elle
occupe toute la surface du Workbench (en masquant les autres vues).
Un nouveau double-clic sur cet onglet permet de revenir à la disposition antérieure.

U ndo / Re do
Les dernières actions d'édition peuvent être annulées avec la fonction Undo disponible dans le menu
Edit Undo ou en utilisant le raccourci associé Ctrl+ Z.
Les dernières actions annulées peuvent être ré-exécutées avec la fonction Redo disponible dans le
menu Edit Redo ou en utilisant le raccourci associé Ctrl+ Y.

Code Folding
Certaines structures du code (classes, méthodes, instructions d'importation,
…) peuvent être temporairement réduites à une seule ligne en cliquant sur
les flèches placées dans la marge gauche de la fenêtre d'édition.
Cette technique appelée code folding permet d'avoir une vue d'ensemble
de la structure du code en masquant les détails de certaines régions.
Un nouveau clic sur la flèche d'une structure réduite permet de revenir à
l'affichage intégral du code pour la structure considérée.

U t ilisa t ion de la vue Out line

La vue Outline présente de manière arborescente la structure du code en
listant les noms des champs, des méthodes, des classes internes, etc. du
fichier ouvert dans l'éditeur.
En cliquant sur un élément de la vue Outline, l'éditeur se positionne sur la
portion de code qui correspond à l'élément sélectionné.

Le bouton de la barre d'outils générale permet de ne visualiser dans

l'éditeur que le code de l'élément sélectionné dans la vue Outline. Un
nouveau clic sur ce bouton rétablit l'affichage complet du code.

Cré a t ion de m odè le s de c ode ( T e m p l a t e s)

Il est possible de créer et de mémoriser des fragments de code auxquels on donne un nom et que l'on
peut ensuite insérer dans l'éditeur au moyen du raccourci d'assistance de codage : Ctrl+ Space.

Ces fragments de code appelés Templates peuvent être créés en utilisant le menu Window
Preferences Java Editor Templates puis en cliquant sur le bouton New . Différentes
variables pré-définies peuvent être utilisées (date courante, nom de la méthode englobante, code
sélectionné, etc.) lors de la création de ces Templates.
Un certain nombre de Templates sont pré-définis. Ils correspondent aux instructions de base du langage
Java ainsi qu'à certaines balises de documentation (Javadoc).
D'autres fragments de code automatiquement insérés lors de la création de classes, constructeurs,
méthodes, etc. peuvent être définis en utilisant le menu Window Preferences Java Code
Style Code Templates

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 5

C OM PI LAT I ON
Dans la configuration par défaut, la compilation (Incremental Build) s'effectue lorsqu'on sauvegarde un
fichier source (par le menu File Save ou en cliquant sur le bouton ou à l'aide du raccourci Ctrl+ S).

Le menu Project Build Project permet de forcer la compilation (Full Build) de tout un projet. Le
menu Project Clean… forcera une recompilation complète du projet lors de la prochaine sauvegarde.
Les erreurs de compilation sont signalées dans les marges gauche et droite de la fenêtre d'édition ainsi
que dans la vue Problems où se trouvent les messages associés à chacune des erreurs.

L AN CEM EN T D ' U N E APPLI CAT I ON

L'exécution d'une application (classe contenant une méthode main()) peut s'effectuer de différentes
manières (Le menu Run rassemble la plupart des fonctions liées à l'exécution des applications).
Pour une application simple (sans paramètres de lancement) on peut utiliser le menu déroulant du
bouton et sélectionner l'option Run As Java Application. Cela lancera la méthode main() du
fichier source actuellement actif dans l'éditeur et créera automatiquement une configuration d'exécution
par défaut.
Une application peut également être lancée en invoquant le menu contextuel du Package Explorer ou de
la vue Outline (Run Java Application) en se positionnant préalablement sur la classe concernée.
Il est également possible de définir manuellement une configuration d'exécution réutilisable à laquelle
on donnera un nom et qui mémorisera toutes les informations de lancement.

Pour définir une configuration d'exécution, on peut utiliser le menu déroulant du bouton et
sélectionner l'option Run… qui démarre un assistant permettant de définir tous les paramètres de
lancement et de les mémoriser sous un nom donné (champ "Name:").

Le lancement d'une application à partir d'une configuration d'exécution existante s'effectue en utilisant
le menu déroulant du bouton et en sélectionnant l'option Run… qui affichera la liste de toutes les
configurations d'exécution disponibles. Une liste des dernières applications lancées est également
disponible (accès direct).

Le bouton permet de ré-exécuter la dernière configuration d'exécution.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 6

E X ÉCU T I ON EN M ODE D EBU G
Le lancement d'une application en mode Debug est très similaire au lancement normal d'une application
(voir ci-dessus). La différence réside simplement dans l'utilisation du menu déroulant du bouton (au
lieu d'utiliser celui du bouton ).
Le lancement en mode Debug fait également appel aux configurations d'exécution. Dans les
configurations d'exécution, il est possible d'indiquer que l'on souhaite un point d'arrêt (Breakpoint) au
début de la méthode main() (case à cocher "Stop in main").

Le lancement d'une application en mode Debug provoque l'affichage d'une perspective pré-définie. Cette
perspective appelée Debug affiche différentes vues spécifiques à ce mode de travail.

Navigation Commands Perspective Debug

Threads Variables

Current
Statement

Breakpoint

Console

Pour définir un point d'arrêt (Breakpoint) il suffit d'effectuer un double-clic dans la marge gauche de
l'éditeur (quelle que soit la perspective utilisée). Un point bleu ( ) confirme visuellement l'emplacement
du point d'arrêt (attention : des points d'arrêt ne sont possibles qu'avant une instruction exécutable, on ne
peut pas, par exemple, placer un point d'arrêt sur une déclaration de variable locale ou sur une accolade
de début ou de fin de bloc d'instructions).
Lorsque le programme est suspendu, le contenu des variables peut être consulté en utilisant la vue
"Variables" ou en positionnant le curseur (dans le code source) sur la variable à inspecter ce qui va
provoquer l'affichage d'une bulle d'aide (Tooltip) indiquant le contenu de la variable.

On peut exécuter un programme pas à pas à l'aide des commandes Step Over ( / F6) ou Step Into
( / F5), poursuivre jusqu'au prochain Breakpoint avec Resume ( / F8) ou arrêter l'application ( ).
Il est possible d'évaluer des expressions, de modifier la valeur de certaines variables et même - dans
certaines limites - de modifier le code source avant de reprendre l'exécution du programme (Resume ).
Consulter la documentation (Help) pour découvrir les riches fonctionnalités offertes par le debugger.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 7

S U PPRESSI ON D ' U N FI CH I ER SOU RCE ( OU AU T RES RESSOU RCES )

Pour supprimer un fichier source ou une autre ressource (dossier, package, …) du projet, il suffit, dans le
Package Explorer, d'invoquer l'option Delete du menu contextuel de la ressource considérée.
Attention : Cette option efface définitivement du répertoire le fichier associé à la ressource (le fichier
source .java par exemple).

S U PPRESSI ON D ' U N PROJ ET

Pour supprimer un projet, il suffit, dans le Package Explorer, d'invoquer l'option Delete du menu
contextuel du projet considéré.
Vous pouvez choisir de supprimer le projet sans supprimer les ressources associées (les sous-
répertoires et les fichiers) qui se trouvent dans le répertoire ou alors d'effacer définitivement toutes les
ressources.

Remarque : La fonction d'importation (Menu File I mport… Existing Project into Workspace)
permet de restaurer un projet effacé dont on a conservé toutes les ressources.

I M PORT AT I ON DE CODE SOU RCE EX T ERN E

Si l'on souhaite importer du code source existant dans un projet il y a plusieurs manière de procéder. Le
choix de la méthode à utiliser dépend de l'emplacement du code source et de la forme sous laquelle il
est disponible.

I m port a t ion pa r c opie r/c olle r

L'importation de code source que l'on peut afficher dans une application quelconque (par exemple : code
source disponible sur le web et affiché dans un navigateur, code affiché dans un traitement de texte,
code au format PDF et affiché avec Acrobat Reader, etc.) peut facilement être importé par copier/coller.
Il faut procéder comme suit :
1) Sélectionner le projet dans lequel le code source doit être importé (créer un nouveau projet si nécessaire).
2) Créer avec Eclipse la classe en la plaçant dans le package souhaité et en faisant bien attention à respecter
strictement l'orthographe du nom de la classe à importer (y compris les minuscules/majuscules).
3) Copier le texte du code source dans le clipboard (Ctrl+ C) puis le coller dans la fenêtre d'édition d'Eclipse
(Ctrl+ V), en remplacement du code généré par l'assistant (conserver l'instruction package…).
4) Reformater éventuellement le code source importé (Source Format ou Ctrl+ Shift+ F)
5) Sauvegarder et compiler la classe (Ctrl+ S)

Remarque : Cette technique d'importation fonctionne bien s'il y a peu de classes à importer, si le code
source n'est pas disponible sur un serveur de fichiers et/ou si le code source n'est pas dans
un format directement importable.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 8

I m port a t ion à pa rt ir de fic hie rs e x t e rne s
L'importation à partir de fichiers externes (disponibles sur un serveur de fichiers) s'effectue à l'aide du
menu File I mport… File system qui invoque un assistant.
Marche à suivre :
1) Sélectionner les répertoires et fichiers à importer (From directory)
(des options de filtrage sont disponibles en pressant sur le bouton Filter Types…).
2) Indiquer dans quel projet, dossier, package les fichiers doivent être importés (Into folder)
(le répertoire actuellement sélectionné dans le Package Explorer est proposé par défaut).
3) Choisir les options d'importation (attention : l'emplacement des fichiers sources doit respecter l'arborescence
des packages définie par les directives package… de ces fichiers sources).

Les fichiers sources seront copiés dans le Workspace, à l'emplacement indiqué.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 9

I m port a t ion à pa rt ir d'un fic hie r J AR ou Z I P
L'importation de codes sources rassemblés dans un fichier comprimé (format JAR ou ZIP) s'effectue à
l'aide du menu File I mport… Archive file qui invoque un assistant.

1) Sélectionner le fichier archive contenant les fichiers à importer (From archive file)
(des options de filtrage sont disponibles en pressant sur le bouton Filter Types…).
2) Indiquer dans quel projet, dossier, package les fichiers doivent être importés (Into folder)
(le répertoire actuellement sélectionné dans le Package Explorer est proposé par défaut).

Les fichiers sources seront copiés dans le Workspace, à l'emplacement indiqué.

Remarques : Si le fichier ZIP est disponible sur un serveur WEB ou FTP, un téléchargement dans un répertoire
temporaire est préalablement nécessaire.
L'emplacement des fichiers sources doit respecter l'arborescence des packages définie par les
directives package… de ces fichiers sources (généralement, le contenu du fichier ZIP est structuré
de manière à respecter cette arborescence, mais ce n'est pas obligatoirement le cas).
Si nécessaire, la fonction Move (Refactor Move…) permet de déplacer ultérieurement des
fichiers sources d'un package à un autre (également possible par Drag&Drop).

I m port a t ion à pa rt ir d'un proje t e x t e rne

Un projet Eclipse créé dans un autre Workspace peut être importé à l'aide du menu File I mport…
Existing Project into Workspace.
Cette importation crée un nouveau projet dans le Workspace courant mais ne copie pas les fichiers (ils
seront référencés en conservant leur emplacement originel).

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 10

A J OU T D ' U N E LI BRAI RI E EX T ERN E AU PROJ ET

Si un projet nécessite l'utilisation d'une classe ou d'une librairie externe, il faut l'indiquer en complétant le
Build Path enregistré dans les propriétés du projet (accès par le menu Project Properties ou par le
menu contextuel Properties du projet).

Il faut ensuite aller dans la branche Java Build Path et sélectionner l'onglet Libraries :

Il faut distinguer les deux situations suivantes :

la librairie externe est définie par une arborescence de fichiers .class
la librairie externe est empaquetée dans un fichier JAR

Libra irie sous form e de fic hie rs .class

Cliquer sur le bouton Add Class Folder… puis Create New Folder… puis Advanced>> .
Donner un nom (quelconque) au dossier (Folder name), cocher la case Link to folder… puis cliquer
sur le bouton Browse… pour sélectionner le répertoire racine de l'arborescence des classes (attention à
bien sélectionner le répertoire parent de celui représentant le package de plus haut niveau de la librairie).

Cliquer ensuite sur OK (4 fois) pour fermer toutes les boîtes de dialogue.
La librairie externe n'est pas incluse dans le Workspace mais simplement référencée dans le dossier qui
a été créé (Linked Folder).

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 11

Libra irie sous form e de fic hie r J AR
Cliquer sur le bouton Add External JARs… puis rechercher et sélectionner le fichier JAR externe.

Cliquer ensuite sur Open puis OK pour fermer les boîtes de dialogue.

Dans le Package Explorer, les librairies externes sont représentées, dans l'arborescence du projet, par
des icônes spécifiques selon le type de librairie : fichiers .class ( ) ou fichier JAR ( ).

Il est possible de consulter le contenu des librairies en ouvrant ( + ) le dossier correspondant.

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 12

U T I LI SAT I ON DE RESSOU RCES SE T ROU V AN T DAN S D ' AU T RES PROJ ET S

Si un projet nécessite l'utilisation de ressources enregistrées dans un ou plusieurs autres projets

(typiquement l'accès à des librairies générales que vous avez développées), il faut référencer ces
ressources externes en complétant le Build Path du projet (accès par le menu Project Properties ou
par le menu contextuel Properties du projet).

Il faut ensuite aller dans la branche Java Build Path, sélectionner l'onglet Projects et sélectionner les
projets qui doivent être inclus dans la liste des emplacements à considérer lors de la recherche de
ressources (Build Path) :

Remarque : Seuls les projets ouverts peuvent être désignés comme emplacements à considérer lors de la recherche
de ressources. Les projets contenant des librairies générales doivent donc être laissés ouverts.

L'ordre dans lequel les recherches sont effectuées peut être défini avec l'onglet Order and Export, en
utilisant les boutons Up et Down pour déplacer dans la liste l'entrée sélectionnée.

Export

La case à cocher [Export] à gauche de chaque entrée de cette liste n'a rien à voir avec l'ordre de recherche.
Elle permet d'indiquer (si elle est cochée) que la librairie ou le projet considéré sera transitivement exporté
(c-à-d que le projet qui référencera comme ressource externe le projet dont on est en train de changer les
propriétés, importera automatiquement la librairie ou le projet dont on a coché la case {à lire calmement ;-} ).

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 13

D ÉPLOI EM EN T D ' U N E APPLI CAT I ON SOU S FORM E DE FI CH I ER J AR

Cré a t ion du fic hie r J AR

Les fichiers JAR (Java Archive) permettent de rassembler dans une seule entité, toutes les ressources
nécessaires au fonctionnement d'un composant logiciel, d'une librairie ou d'une application (fichiers
compilés .class, images, documentation, …). Ils permettent de simplifier la distribution de librairies,
d'applications, etc. en incorporant l'ensemble des ressources nécessaires dans un seul fichier.
Les fichiers JAR utilisent le même format que les fichiers ZIP et, comme eux, ils permettent de structurer
le contenu sous une forme arborescente (avec des répertoires et sous-répertoires) et de comprimer
optionnellement le contenu (réduire la taille du fichier).
Les fichiers JAR contiennent un fichier particulier, appelé Manifest File ([Link]), qui donne des
informations (méta-informations) sur le contenu du fichier JAR. Dans le cas d'une application, le Manifest
File doit indiquer le nom de la classe principale (celle qui contient la méthode main()).

L'outil de base pour créer et gérer les fichiers JAR est l'utilitaire jar qui fait partie du SDK. Avec
l'environnement de développement Eclipse, un assistant permet de créer un fichier JAR de manière plus
conviviale qu'en travaillant avec la ligne de commande (Command Prompt).

Pour lancer cet assistant, il faut passer par le menu : File Export JAR File

Il suffit ensuite de sélectionner les ressources qui doivent y être placées, d'indiquer l'emplacement et le
nom du fichier JAR , de créer éventuellement fichier de description (voir ci-dessous) et de demander de
générer le fichier Manifest en indiquant la classe principale (le point d'entrée de l'application).
Les informations qui servent à générer le fichier JAR peuvent être mémorisées sous forme d'un fichier de
type "JAR Description" qui apparaîtra dans la vue Package Explorer et qui servira à re-générer une
nouvelle version du fichier JAR sans avoir à réutiliser l'assistant.

Re m a rque s c onc e rna nt l'a c c è s a ux re ssourc e s da ns un fic hie r J AR

Si l'on place des ressources (images, logos, sons, etc.) dans un fichier JAR, l'extraction de ces ressources s'effectue
en utilisant la méthode getResource() de la classe class. Cette méthode renvoie l'URL de la ressource (c'est le
Class Loader qui se charge de localiser la ressource demandée en fonction de la situation qui prévaut).
Exemple : URL fUrl = getClass().getResource("[Link]");
Image image = [Link]().getImage(fUrl);
ou, dans une méthode statique :
URL fUrl = [Link]("[Link]");

Cette technique fonctionne si la ressource se trouve soit dans un répertoire défini comme Classpath, soit dans le
fichier JAR. On peut naturellement placer la ressource dans un sous-répertoire ("images/[Link]").
L'imbrication de fichiers JAR n'est pas directement supportée en Java. Il est conseillé de déployer les différents
fichiers JAR dans les emplacements souhaités et de les référencer dans le fichier Manifest du fichier JAR principal
en utilisant le mot clé Class-Path.
Exemple : Class-Path: . lib\[Link] lib\[Link]
(le point "." représente le répertoire courant)

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 14

A U T RES FON CT I ON S

Configura t ion de l'e nvironne m e nt

Le menu Window Preferences permet de configurer de nombreux aspects de l'environnement de
développement.
Les options de configuration sont classées de manière arborescente
Pour chacun des domaines, il est toujours possible de revenir à la configuration par défaut grâce au
bouton Restore Defaults (attention, cela restaure les options par défaut de tous les onglets du groupe
considéré).

Re fa c t oring
Différentes fonctions de Refactoring (adaptation du code source sans changer la sémantique) sont
disponibles dans le menu Refactor.

Il est notamment possible de changer le nom d'une ressource (Refactor Rename…) ou de déplacer
une ressource (Refactor Move…). D'autres fonctions plus spécifiques existent également.

Re st a ura t ion à pa rt ir de ve rsions pré c é de nt e s

Eclipse garde en mémoire l'historique des changements intervenus dans les fichiers sources. Cet
historique appelé Local History est mémorisé dans des fichiers spécialisés du Workspace.
Les paramètres de conservation des informations (durée, nombre de changements, …) peuvent être
définis par le menu Window Preferences General Workspace Local History. Par défaut,
les anciennes versions sont conservées durant 7 jours.
Pour restaurer l'état d'un fichier source tel qu'il se trouvait à un moment donné, il faut sélectionner le
fichier source concerné dans le Package Explorer puis, dans le menu contextuel, invoquer l'option
Replace w ith Local history… . La liste des versions disponibles (avec dates et heures) figure dans
le panneau supérieur et une comparaison des contenus est affiché dans les deux panneaux inférieurs
(version actuelle / version antérieure).

Le bouton Replace permet de restaurer la version sélectionnée.

Re st a ura t ion de re ssourc e s e ffa c é e s

Les ressources effacées peuvent également être restaurées à partir de l'historique (Local History).
Pour restaurer une ressource effacée (fichier source par exemple), il faut, dans le Package Explorer,
sélectionner le projet, le dossier ou le répertoire dans lequel le fichier doit être restauré puis, dans le
menu contextuel, invoquer l'option Restore from Local history… .
Les ressources disponibles pour la restauration (s'il y en a) sont affichées dans le panneau supérieur
gauche et la liste des versions disponibles (avec dates et heures) dans le panneau supérieur droit. Le
contenu de la ressource sélectionnée est affiché dans le panneau inférieur.
Le bouton Restore permet de restaurer la ressource sélectionnée.

Dé finit ion de Work ing Se t s

Lorsque l'on a de nombreux projets dans un Workspace, la vue Package Explorer peut devenir très
chargée et il est parfois difficile de s'y retrouver. Il est recommandé de fermer les projets avec lesquels
on ne travaille pas momentanément (menu contextuel Close Project), mais ils restent affichés.
On peut également définir des Working Sets pour restreindre les ressources affichées ainsi que pour
limiter les ressources affectées lors de l'exécution de certaines opérations (la recherche par exemple).

Pour définir des Working Sets, on utilisera le menu déroulant du Package Explorer ( ) en sélectionnant
l'option Select Working Set… puis en cliquant sur le bouton New .
On peut ensuite donner un nom au Working Set et sélectionner les ressources associées (celles que l'on
souhaite voir dans le Package Explorer).

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 15

U t ilisa t ion de Book m a rk s
On peut mémoriser des emplacements dans le code source en enregistrant des signets (Bookmarks).
Il suffit de se positionner avec le curseur dans la marge gauche de l'éditeur, à la hauteur de la ligne
concernée et d'invoquer le menu contextuel Add Bookmark… puis de donner un nom au signet.
La vue Bookmarks rassemblant les signets n'est pas affichée par défaut. On peut l'ajouter à la
perspective courante par le menu Window Show View Other… Basic Bookmarks.
Dans la vue Bookmarks, un double-clic sur le signet fait sauter l'éditeur à l'emplacement associé.

T ra nsfe rt d'un Work spa c e

Un Workspace peut être transféré d'un emplacement à un autre, par exemple d'une machine à une
autre, en copiant simplement tout le contenu du répertoire correspondant au Workspace (il faut
préalablement arrêter l'application Eclipse pour que tous les fichiers soient dans un état cohérent).
Le répertoire de destination ne doit pas forcément posséder le même nom que celui d'origine. Il suffira
d'indiquer à Eclipse l'emplacement du répertoire créé lors de la sélection du Workspace.

T ra nsfe rt d'un proje t d'une m a c hine à une a ut re

Un projet enregistré dans un Workspace sur une machine A peut être transféré dans le Workspace d'une
machine B, en copiant tout le contenu du répertoire du projet (de la machine A) dans le Workspace de
destination (sur la machine B). Il est impératif d'arrêter Eclipse sur les deux machines avant le transfert
de manière à garantir l'intégrité des fichiers transférés.
Il faut ensuite démarrer Eclipse sur la machine de destination (B), ouvrir le Workspace cible et importer le
projet transféré à l'aide du menu File I mport… Existing Project into Workspace puis en
recherchant le répertoire du projet avec le bouton Browse… .

H e lp
Une aide contextuelle peut être invoquée à tout moment en pressant sur F1.

Le menu Help offre différentes options d'aide en ligne, notamment :

Des pages d'introduction pour débutant : Help Welcome… ...
Un guide d'utilisation du Workbench : Help Help Contents Workbench User Guide
Un guide d'utilisation du JDT : Help Help Contents Java Development User Guide
Une recherche par mots-clés : Help Search
Une recherche par mots-clés : Help Key Assist...
Une rubrique "trucs et astuces" : Help Tips and Tricks… ...
Divers didacticiels (assistants pas à pas) : Help Cheat Sheets

La documentation est également disponible sur le web :

[Link]/documentation/[Link]

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 16

Q U ELQU ES FON CT I ON S ET RACCOU RCI S U T I LES

Les raccourcis clavier mentionnés correspondent au Standard Key Binding d'Eclipse.

Work be nc h
Affichage d'une vue ou d'une fenêtre d'édition en
plein écran (idem pour le retour à l'affichage Double-clic sur la barre de titre
normal)
Restauration de la disposition par défaut des
Window s Reset Perspective
sous-fenêtres d'une perspective pré-définie
Aide contextuelle F1
Affichage des raccourcis clavier disponibles Ctrl+ Shift+ L

Édit ion
Assistance de codage
- Autocompletion
- Template Expansion Ctrl+ Space
- Parameter List
-...
Sélectionner la ou les lignes concernées puis :
Modification du niveau d'indentation du code
Tab ou Shift+ Tab
Positionner le curseur sur la ligne concernée ou
Déplacement de lignes de code sélectionner plusieurs lignes puis :
Alt+ ou Alt+
Formatage du code Ctrl+ Shift+ F
Undo : Annuler la dernière action Ctrl+ Z
Redo : Rétablir la dernière action annulée Ctrl+ Y
QuickFix Proposition de correction d'erreur ou de
modification spécifique du code sélectionné Ctrl+ 1
(affichage d'une liste de propositions)
Recherche incrémentale (avant/arrière) Ctrl+ J Text
Mise en commentaire des lignes sélectionnées Ctrl+ 7
Affichage contextuel de la JavaDoc Shift+ F2
Sauvegarde et compilation Ctrl+ S

Ex é c ut ion d'une a pplic a t ion

Run last launched Ctrl+ F11

De bugge r
Debug last launched F11
Step over F6
Step into F5
Resume F8
Run to line (indicated by the cursor position) Ctrl+ R

A U T RES RESSOU RCES

Quelques liens utiles sont disponibles sur la page web :

[Link]/~jbapst/links/[Link]#IDE

D:\Data\EIA\Cours\PR1\Eclipse3.1_Premiers_Pas.doc EIA-FR / Jacques BAPST 17