Vous êtes sur la page 1sur 11

Prise en main de l’IDE Eclipse

Guillaume Santini
Dpt. d’iInformatique de l’IUT de Villetaneuse - Université Paris-Nord
19 octobre 2015

1 Présentation
Eclipse est une plateforme de développement de logiciels intégrant de nombreux outils facilitant le travail
d’un programmeur ou d’une équipe de programmeurs. Cette solution propose notamment un IDE (environne-
ment de développement intégré) qui sera présenté dans ce tutoriel. L’IDE permet de gérer de très nombreux
aspects du développement d’un logiciel : la programmation, la modélisation, les tests unitaires. Mais Eclipse est
plus que cela et permet en plus le développent d’une documentation, le partage des sources, le versionnement,
. . ..
C’est une solution gratuite et multi-plateforme (Windows, Mac, Linux . . .), qui supporte plusieurs langages de
programmations (Java, C++, HTML, . . .).
La bonne utilisation d’une telle plateforme, en plus de permettre un développement plus rapide, permet égale-
ment de satisfaire à de nombreuses règles de qualité d’un programme. Il est donc conseillé de se reporter lors
de vos temps libres à la lecture de la documentation intégrée à l’outil, afin de découvrir, de vous familiariser ou
encore d’approfondir certaines étapes de développement d’un logiciel.

2 Premier lancement
Le premier lancement donne lieu à plusieurs paramétrages qui doivent être effectués une seule fois.

2.1 Répertoire de travail


La première fenêtre vous invite à spécifier le répertoire de base dans lequel Eclipse sauvegardera tous les
fichiers (y compris les projets et leurs fichiers de code).

Normalement VOTRE_LOGIN correspond à votre nom d’utlisateur. Nous vous conseillons de ne pas modifier ce
chemin par défaut à moins de savoir exactement ce que vous faîtes.
Pensez à cliquer sur le bouton radio pour que la fenêtre ne s’ouvre pas à chaque lancement d’Eclipse .

2.2 Lancement du Workbench


Lors du premier lancement, Eclipse affiche une fenêtre vous permettant d’accéder à différentes ressources de
prise en main de l’application. Nous sautons ici cette étape, mais si vous désirez devenir un expert d’Eclipse nous
vous conseillons de parcourir ces ressources sur votre temps libre.

1
Pour arriver à la perspective de développement cliquez sur l’icône .

2.3 La perspective "Java"


La perspective de développement Java est un ensemble de fenêtres (aussi appelées "vues") sélectionnées pour
simplifier le développement d’une application Java.

La perspective est constituée :


— à gauche la vue "Pakage Explo"qui donne un aperçu sur les différents projets disponibles et leur organi-
sation sur le disque dur„
— au centre la vue "Edition", propose un éditeur intégré (affichage et édition du code),
— à droite la vue "Outline", qui résume le contenu du fichier affiché dans la vue "Edition", en terme de
classes, attributs et méthodes,
— en bas plusieurs vues organisées en onglets dont la principale est la "Console"qui joue le rôle d’entrée et
de sortie standards pour les programmes utilisant une interface texte.

2
Pour l’instant ces vues sont vides car aucun projet n’a encore commencé. Nous reviendrons sur leur contenu au
cours de la prise en main.

3 Première étape : Création d’un projet


Eclipse permet de gérer plusieurs projets en parallèle. On entend par "projet" une brique logicielle plus ou
moins indépendante présentant une certaine unité. Dans le cadre du module d’introduction vous serez amené
créer plusieurs projets. Par exemple :
— Projet Luminaire pour les TP
— Projet DansLePre pour les exercices supplémentaires des TP,
— Projet Dessin pour les exemples du cours.
— Projet TitreADeterminer pour le projet UML/Java.

3.1 Principes mis en œuvre


La création d’un projet s’accompagne de la création d’une arborescence sur le disque permettant d’enregistrer
l’ensemble des fichiers et répertoire liés au projet.
Comme pour beaucoup de choses, Eclipse automatise cette tâche au moyen de fenêtres ou de Wizards qui vous
demandent certains paramètres, Eclipse prenant en charge toutes les opérations fastidieuses.
À titre indicatif, un Wizard est un ensemble de fenêtres qui s’affichent les unes à la suite des autres, dans un
ordre précis, guidant l’utilisateur dans la saisies de paramètres. La navigation d’une fenêtre à l’autre se fait au
moyen de boutons Next , Previous , Finish , avec blocage si certains champs obligatoires ne sont pas renseignés.

3.2 Création Pas à Pas


Ici nous allons opter pour la création d’un projet simple, sans dépendances ni importation de fichiers,
réduisant le nombre d’étapes de création du projet à une seule : le choix du nom du projet. Pour lancer le Wizard
de création de projet, sélectionnez à partir de la barre de menu principale : File > New > Java Project :

Puis suivez les indications des fenêtres du Wizards. Vous utiliserez comme nom de projet : ProjetTest puis
cliquer sur Finish .

3
3.3 La vue projet est modifiée
La création du projet modifie la vue "Pakage Explo"(vue de gauche). Celle-ci propose désormais le nouveau
projet ProjetTest. A tout instant vous pourrez explorer le contenu du projet en cliquant sur son nom. On
observe ainsi, qu’avec la création d’un répertoire portant le nom du projet, un sous-répertoire src a été créé.
Celui-ci contiendra notamment tous les fichiers source de votre application.

À ce point le nouveau projet est créé mais ne contient encore aucun fichier. Nous allons maintenant voir comment
développer ce projet.

4 Création d’une classe comportant un programme exécutable par le


système
4.1 Création de la classe
En POO, tout programme est défini comme une méthode de classe. Pour faire ce premier programme nous
allons commencer par créer la classe qui va le supporter.

Une des fonctionnalités principale d’Eclipse est de vous assister dans la création des classes et des fichiers
de code associés. Ainsi, grâce à l’IDE, vous allez pouvoir générer automatiquement une partie du code associé
à la déclaration d’une classe.

Pour cela, cliquer avec le bouton droit de la souris sur le projet dans la vue "Pakage Explo", puis choisir
successivement : New > Class

Une fenêtre de paramétrage de la nouvelle classe apparait. Dans celle-ci vous devez renseigner le package dont
cette classe fait partie (ici aucun, donc laissez le champs vide), le nom de la classe (ici choisissez TestHello pour
nom de classe) et divers paramètres non utiles pour l’instant. Vous veillerez cependant à sélectionner l’option
public static void main(String [] args) afin que l’entête de cette méthode soit intégrée directement au
fichier généré. Une fois les paramètres remplis, le bouton Finish est rendu actif. En le pressant, vous créez la
classe voulue et le fichier associé :

4
4.2 Impact de la création d’une classe sur les vues
La création de la nouvelle classe est directement prise en compte par Eclipse qui met alors la perspective à
jour :

— Dans la vue "Pakage Explo"le nom du fichier de la classe qui vient d’être créé apparait. Le nom du fichier
prend la forme canonique NomDeLaClasse.java, soit ici TestHello.java
— Dans la vue d’Edition, le fichier contenant le code est affiché,

5
— Dans la vue Outline, la liste des méthodes définies dans ce fichier s’affiche (ici une seule méthode : main())
En fait, lors de la création d’une classe, Eclipse génère un fichier à trous, contenant les entêtes définies par
le paramétrage.

4.3 Compléter la classe TestHello


Afin de compléter la classe TestHello nous allons ajouter des instructions à la méthode main(). Dans la
vue Edition, ajoutez à la classe main() l’instruction suivante :
System.out.println("Hello World!") ;

Lors la saisie de ce code, une fenêtre de choix contextuel s’affiche vous proposant, en fonction du texte que vous
avez commencé à saisir, le nom de méthodes pouvant convenir. En sélectionnant une de ces propositions (clique
ou pression de la touche Enter sur l’item sélectionné), Eclipse complète le code en cours d’écriture par un
template (code à compléter).

Vous remarquerez également que, tant que le code n’est pas correct (faute de syntaxe, méthode inconnue, . . .)
une croix rouge apparait en marge du code (à gauche). Tant qu’il reste des votre code ne peut être
compilé en ByteCode.
À l’issue de cette étape vous disposer d’une classe exécutable.

4.4 Éxécution de la classe


La classe que nous venons de créer possède une méthode qui peut-être appelée par le système (la méthode
main(). Après avoir sauvegardé vos modifications (File > Save ou Ctrl + S ), il est possible de tester
l’exécution de cette classe directement depuis Eclipse sans passer par la compilation et l’exécution en ligne de
commande. En effet, Eclipse est un environnement de travail complet qui permet de développer mais aussi
d’exécuter du code.
Cet ensemble de tâches (compilation et appel de la classe compilée pour exécution) se fait de façon conjointe
au moyen de fenêtres dédiées. Pour ce faire, vous devez procéder ainsi : dans la vue "Pakage Explo"(à gauche),
cliquez avec le bouton doit de la souris sur la classe (i.e. le fichier) que vous souhaitez exécuter puis sélectionnez
dans le menu qui apparait : Run As > Java Application.
Cette action aura pour effet de compiler votre code et ses dépendances si elles ont changé, et d’exécuter la
méthode main().

6
Si l’exécution donne lieu à un affichage en ligne de commande, alors ces affichages prendront place dans la vue
Console située en bas de la perspective. Ici, le message "Hello World!" doit s’afficher dans la "Console" :

5 Développement de classes
5.1 Objectifs
Eclipse suit la règle suivante : à chaque classe correspond un fichier. Ici, nous allons suivre les règles
d’Eclipse qui s’inspirent des "Bonnes Pratiques" admises dans le petit milieu des programmeurs.
Nous allons dans les prochaines étapes développer une classe PointPlan, comme celle qui a été vue en cours. Ceci
nous permettra d’introduire d’autres fonctionnalités d’Eclipse . Le modèle Uml de cette classe est le suivant :
PointPlan
- abs : float
- ord : ord
+ PointPlan(x : float, y : float)
+ getAbs() : float
+ getOrd() : float
+ setAbs(x : float)
+ setOrd(y : float)
+ toString() : String

7
5.2 PointPlan : Définition d’une classe avec variables et méthodes
5.2.1 Création de la classe
En suivant la procédure détaillée dans la partie 4.1, nous allons commencer par créer la classe PointPlan.
La seule différence est qu’ici la classe ne comportera pas de méthode main(). À l’issue de cette étape vous devez
obtenir un environnement qui correspond à la perspective suivante, et qui intègre une classe PointPlan vide.

5.2.2 Ajout des variables d’instance


Manuellement vous pouvez ajouter dans la vue "Edition", le code correspondant à la déclaration des 2
variables d’instance abs et ord. Vous devez alors obtenir la perspective suivante :

Vous noterez que le contenu de la vue "Outline"a été mis à jour pour tenir compte de l’ajout des variables abs
et ord. La mise à jour est automatique à toutes les étapes, dès que vous rajouterez dans un fichier une classe,
une variable de classe ou d’instance ou encore une méthode.
Vous devez aussi remarquer que des points d’exclamation sont apparus dans les vues "PackageExplo", "Edi-
tion"et "Outline". Comme les croix rouges , elles sont l’indicateur que quelque chose n’est pas comme "cela
devrait être". Les sont des "warnings" (ils ne bloqueront pas la compilation, par contre les provoqueront
une erreur à la compilation).
Il vous faudra "faire la chasse" à ces indicateurs et corriger votre code pour les supprimer. Une indication sur
la nature du problème détecté vous est donné par Eclipse : en plaçant votre souris sur le signe dans la marge
de la vue "Edition", Eclipse affiche une petite fenêtre expliquant la nature du problème :

Par exemple ici, Eclipse détecte des variables d’instance privées qui ne sont utilisées (lues) nulle-part. Elles lui
paraissent donc suspectes. . .. Afin de lever ce soucis nous allons ajouter plusieurs méthodes qui vont utiliser ces
variables.

5.2.3 Création des méthodes usuelles


Eclipse vous assiste dans la création des méthodes usuelles associées à chaque classe, telles que les
constructeurs, les méthodes d’accès en lecture et en écriture sur les variables (privées pour respecter le principe
d’encapsulation) ou encore les méthodes toString() ou equals. Ceci se fait en cliquant avec le bouton droit
de votre souris sur le nom de la classe dans la vue "Pakage Explo"ou directement dans la vue "Edition"si le
fichier de la classe est visible. Dans le menu qui apparait il faut alors sélectionner l’item Source, puis choisir

8
parmi les propositions les méthodes que vous souhaitez inclure dans votre classe.

Dans un premier temps on peut choisir d’intégrer les constructeurs, en sélectionnant


Source > Generate Constructor using Fields ....
La fenêtre qui apparait permet de :
— choisir les variables devant être initialisées par le constructeur champs à champs,
— l’endroit où le code du constructeur sera inséré dans le code de la classe,
— la visibilité de la méthode,
— la génération d’une trame de commentaires et l’appel au constructeur de la classe parente si la classe en
cours de développement est une classe héritant d’une autre et si on souhaite appeler le constructeur de
la classe parente(super().

La pression sur la touche OK , insère le code dans la vue "Edition"et met à jour la vue "Outline" :

9
5.2.4 Ajout des méthodes d’accès
La même opération peut être menée pour ajouter les méthodes d’accès en lecture et en écriture en sélec-
tionnant : Source > Generate Getters and Setters .... Dans la fenêtre de paramétrage suivante, il vous
est possible de choisir les méthodes d’accès que vous souhaitez insérer en cliquant/décliquant les boutons radio.
En pressant sur la touche OK , le code est inséré dans la classe.

Vous obtenez ainsi tout le code suivant en n’ayant tapé que le code de déclaration des variables abs et ord ! !

5.2.5 Ajout de la méthode toString()


L’affichage d’une instance est une pratique courante, surtout en phase de développement. Elle permet d’ex-
plorer le comportement d’un programme en affichant le contenu des variables (affiche sont état).
Comme dans de nombreuses tâches, Eclipse vous assiste dans le développement de cette méthode. Au moyen
de la fenêtre Source > Generate toString() ... vous pouvez insérer rapidement des fonctions de conver-
sion d’une instance en chaîne de caractères. Pour cela, Eclipse vous propose plusieurs modèles paramétrables.

10
Ici nous choisirons d’afficher uniquement le contenu des variables d’instance abs et ord, d’après le style
String.format/MessageFormat :

Le code inséré automatiquement est le suivant :

5.2.6 Pour aller plus loin


Par la suite vous pourrez trouver intéressant d’utiliser d’autres fonctionnalités du menu Source, donc n’hé-
sitez pas à le parcourir régulièrement. Eclipse vous guidera notamment dans la redéfinition de méthodes (dans
un context d’héritage) au moyen de la fenêtre Source > Override/Implements Methods ..., par exemple.

6 Conclusion
Eclipse est un bon compagnon de développement. Dans un premier temps il peut paraitre surdimensionné
par rapport aux premiers projets d’un développeur débutant (et soyons franc, il l’est !). Cependant, il permet
de guider le développeur dans son travail en intégrant les bonnes pratiques ; donc passer un peu de temps à
apprivoiser la bête peut être une bonne solution.
Par ailleurs, nous n’avons abordé ici que la surface de la partie émergée de l’iceberg que constitue Eclipse .
Nous y reviendrons dans des TP ultérieurs, notamment lorsque nous parlerons de debogage et de tests unitaire
avec JUnit.
De nombreuses ressources existent pour approfondir votre connaissance de cet IDE. Parmi celles-ci, il y a la
documentation intégrée dans Eclipse (en anglais, mais très complète). Il existe aussi de nombreuses ressources
sur le net. Par exemple :
http://http://www.enseignement.polytechnique.fr/profs/informatique/Julien.Cervelle/eclipse/
http://http://eclipse.developpez.com/cours/

11

Vous aimerez peut-être aussi