Haut de page

Introduction à l'utilisation d'eclipse

Table des matières

Introduction

Concept

Eclipse est un IDE, Integrated Development Environment (EDI environnement de développement intégré en français), c'est-à-dire un logiciel qui simplifie la programmation en proposant un certain nombre de raccourcis et d'aide à la programmation. Il est développé par IBM, est gratuit et disponible pour la plupart des systèmes d'exploitation.

Au fur et à mesure que vous programmez, eclipse compile automatiquement le code que vous écrivez, en soulignant en rouge ou jaune les problème qu'il décèle. Il souligne en rouge les parties du programme qui ne compilent pas, et en jaune les parties qui compilent mais peuvent éventuellement poser problème (on dit qu'eclipse lève un avertissement, ou warning en anglais). Pendant l'écriture du code, cela peut sembler un peu déroutant au début, puisque tant que la ligne de code n'est pas terminée (en gros jusqu'au point-virgule), eclipse indique une erreur dans le code.

Il est déconseillé de continuer d'écrire le programme quand il contient des erreurs, car eclipse est dans ce cas moins performant pour vous aider à écrire le programme.

Installation

Le logiciel est déjà installé sur vos machines. Il suffit de taper eclipse dans un terminal pour le lancer. Si vous souhaitez l'installer chez vous, eclipse est disponible sur le site http://www.eclipse.org pour linux, BSD, Windows ou MacOS. La version à télécharger est la dernière stable, à savoir pour l'instant la 3.2.x ; cependant, si vous souhaitez avoir la même version que celle installée sur les machines de l'école, il faut choisir la 3.1.2. Cette dernière gère un peu moins bien les types paramétrés (noms de classe avec des <T>). Normalement, la page http://www.eclipse.org/downloads choisit automatiquement la bonne version.

Concurrents

Parmi ses concurrents, on trouve NetBeans (http://www.netbeans.org), gratuit et développé par Sun, IDEA de JetBrain (http://www.jetbrains.com) qui est payant.

Premiers contacts

Workspace

Le workspace est le répertoire dans lequel sont stockés :
  • les projets, c'est-à-dire les différents programmes que vous allez réaliser
  • la configuration d'eclipse
Afin d'éviter de reconfigurer eclipse plusieurs fois, on évite en général de multiplier les workspaces.

Dans le cadre des cours, on utilisera un workspace par cours, et un projet par TD. Par exemple, pour le cours INF431, on aura une organisation comme suit. On utilisera comme répertoire de workspace le répertoire INF431 situé dans le répertoire principal.

Pour chaque TD, on créera un nouveau projet appelé td_x. Après trois TD, la fenêtre ressemblera à cela :
[threeTD]

Premier lancement

Lors du lancement d'eclipse, un splash screen apparaît, suivi d'une fenêtre vous demandant dans quel workspace vous voulez travailler. L'emplacement par défaut est le répertoire workspace dans le répertoire principal, et peut être changé, sans créer le répertoire à l'avance. Par exemple, pour le cours INF431, on choisira la INF431 comme workspace :
[workspace]

Une fois choisi, le programme s'initialise sur la fenêtre suivante :

Pour commencer à travailler, il suffit de fermer l'onglet ou de clicker sur Workbench.

Premières configurations obligatoires

Système de configuration d'eclipse

Comme la plupart des logiciels aboutis, eclipse contient un nombre considérable d'options. La configuration par défaut est en général acceptable, mais il y a certains points qui méritent d'être changés, et d'autre qui doivent l'être (comme par exemple le fait que l'on utilise java 1.5 et non java 1.4).

La fenêtre de configuration s'obtient dans le menu Windows, article Preferences...

Les différentes pages d'options sont choisies dans l'arbre situé sur la gauche de la fenêtre, la page apparaissant sur la droite. Les options relatives à java sont dans le sous-arbre java, celles relatives à l'apparence d'eclipse (font, couleurs) sont dans le sous-arbre General.

Version du compilateur

Les TD de java utilise la version 1.5 de java (mais il peuvent être fait avec la dernière version 1.6). Cependant, pour des raisons de compatibilité ascendante, eclipse est configuré par défaut pour utiliser java 1.4. Pour changer cela, il faut sélectionner la page Java/Compiler, et sélectionner 5.0 dans Compiler Compliance Level (laisser le reste inchangé).
[preferencesCompiler]

Formatage du code

Comme on a dû vous le dire en cours, le formatage du code et l'indentation fondamental pour une relecture et un débogage aisé des programmes. Pour que le formatage soit conforme à ce que l'on attend, il convient de modifier la manière dont eclipse formate les programmes par défaut.

Pour cela, choisir, dans la fenêtre des préférences, la page Java -> Code Style -> Formatter. On obtient la fenêtre suivante :
[format]

Pour définir une nouvelle configuration de formatage, cliquer sur New..., et donner un nom à cette configuration dans la boîte qui s'ouvre, par exemple X :
[format1]

Un fois cliqué sur OK, on peut effectuer les modifications suivantes : dans le cadre General Settings, modifier Tab Policy en "Spaces only" puis indiquer 2 pour "indentation size" et "tab size".
[format2]

Une fois terminé, cliquer sur OK, puis à nouveau sur le bouton OK de la fenêtre de configuration.

Premier projet, Hello world

Comme initiation, nous allons créer et exécuter le traditionnel programme Hello World, en Java, à l'aide d'eclipse.

On commence par créer le projet choisissant File -> New -> Project... :
[fileNew]

On obtient alors un wizard (suite de boîtes de dialogues avec un bouton "Next>" pour passer d'une étape à la suivante). Tout d'abord, on indique que l'on veut créer un projet Java en choisissant "Java project", puis on clique sur "Next>" où l'on indique le nom du projet, par exemple hello. Bien que l'on puisse spécifier plus d'options en cliquant sur "Next>", on clique sur "Finish" pour choisir les options par défaut :
[helloWorld]
[helloWorld1]

Le projet ainsi créé apparaît dans la fenêtre principale :
[helloWorld2]

Ensuite, en cliquant avec le bouton droit sur le projet, on sélectionne New -> Class :
[helloWorld3]

Dans la fenêtre qui s'ouvre, on indique le nom de la classe, Hello, et on coche la case indiquant que l'on souhaite qu'elle contienne une méthode main :
[helloWorld4]

Eclipse crée le squelette de la classe (stub en anglais). Notez le commentaire javadoc préécrit (voir cette section pour plus d'informations), et le commentaire en TODO rappelé dans la marge par l'icône [task].
[helloWorld5]

Il ne reste qu'à compléter la méthode main :
[helloWorld6]

Pour exécuter la classe, clic-droit sur le fichier .java, puis Run As -> Java Application :
[helloWorld7]

L'affichage de l'exécution s'effectue sous l'onglet "console" en bas de la fenêtre principale :
[helloWorld8]

Créations

Projets

Les programmes java d'eclipse s'organisent en projets. Un projet va contenir un certain nombre de fichiers java. C'est à vous de choisir la granularité de votre projet. Par exemple, on pourrait décider de faire un projet par cours, un projet par séance de TD ou un seul projet pour tout. Pour les cours à l'X, on opte pour un projet par TD, plus éventuellement un par projet de programmation. On rappelle que l'on définit une workspace par cours.

Comme vu dans la section Premier projet, Hello world, pour créer un nouveau projet, cliquer sur File -> New -> Project... :
[fileNew]

Après avoir sélectionné Java project, puis lui avoir donné un nom (par exemple td_1 pour le TD n°1), il apparaît dans la liste des projets à gauche sous l'onglet Package Explorer.
[mainWindowTD1]

Incorporations de sources existantes

Pour incorporer des sources (des .java) existants, deux possibilités. Soit on veut créer un nouveau projet à partir de ces sources (par exemple, j'ai commencé le td n°2 avec nedit, puis je souhaite me mettre à eclipse). Dans ce cas, il est plus simple de déplacer le répertoire contenant les sources dans la workspace (sauf si elles y sont déjà). Ensuite, on crée un nouveau projet dont le nom est celui de répertoire, ou si l'on a choisi de laisser les sources en dehors du workspace, on sélectionne "create project from existing sources, puis on indique en dessous le chemin vers le répertoire où elles se trouvent.

Si on souhaite ajouter les sources à un projet existant, il suffit de mettre les .java dans le projet (ou dans le source folder si vous en avez défini un, voir cette option avancée pour voir comment le définir), et de faire un clic-droit sur le projet puis de sélectionner Refresh :
[refresh]

Dans certains cas, le projet peux sembler curieux. En effet, si des .java sont dans un sous répertoire, eclipse considère que les classes définies dans ces fichiers sont dans un paquetage dont le nom est celui du répertoire. Par exemple, si j'ai un répertoire td2 avec des sources à côté de classes du TD3, j'obtient le résultat suivant :
[errorPackage]
Dans ce cas, le plus simple est de déplacer les classes dans le répertoire du projet. Si vous avez une bonne maîtrise du "build path" et de la séparation des sources et des classes, vous pouvez faire un clic droit sur le "package" td2, puis "Build Path" puis "Use as source folder".

Classes, interfaces...

Pour créer une nouvelle classe, clic droit, soit sur le projet, soit sur le répertoire des sources, soit sur un paquetage. Un wizard s'ouvre proposant diverses options, dont le nom de la classe, le nom du paquetage de la classe (pré-rempli si le clic droit était sur un paquetage), avec par exemple si on veut un méthode main. Eclipse crée alors le fichier java à l'endroit qu'il faut, pré-rempli avec les informations demandées :
[newClassWizard]

Création de fichiers textes

Dans certains TD, on demande de créer des fichiers texte contenant des données. Pour créer un fichier texte, choisir File -> New -> Untitled Text File. On obtient la vue suivante :
[textFile] En sauvant le fichier, eclipse nous demande de l'enregistrer en fournissant le projet dans lequel on souhaite l'enregistrer et son nom :
[textFile1]
Le fichier nouvellement créé apparaît alors dans le projet sous l'onglet "Package explorer" :
[textFile2]

Paquetages

Avant d'ajouter des classes, on peut créer des paquetages pour les y mettre. Pour cela, clic droit sur le répertoire des sources, puis new puis paquage. Un wizard demandant le nom de paquetage s'ouvre. Le paquetage apparaît ensuite dans le répertoire des sources :
[newPackage]
[newPackage1]

Pour déplacer des classes entre paquetages, il suffit de le faire par glisser-déplacer, ou avec un clic-droit sur la classe puis Refactor -> Move...

Exécution du programme

Exécution simple

Comme vu dans la section Premier projet, Hello world, exécuter un programme, il suffit de faire un clic-droit sur le .java de la classe, puis de sélectionner Run As -> Java application :
[helloWorld7]

Il est alors possible d'intéragir avec le programme sous l'onglet "Console", en bas de la fenêtre principale. Par exemple, en utilisant la classe TC, on peut écrire et lancer le programme suivant :
[tc1]
en entrant les deux valeurs, on obtient :
[tc2]

Interruption du programme

Notez le carré rouge visible pendant l'exécution. En cliquant dessus, on peut interrompre le programme, par exemple s'il par dans une boucle infinie :
[runLoop]

Exécution d'un programme avec des arguments

Pour exécuter le programme avec des arguments, on effectue un clic droit sur le .java de la classe, puis Run As -> Run... Si la programme a déjà été exécuté dans eclipse, le nom de la classe apparaît dans la liste à gauche, et il faut cliquer sur ce nom. Sinon, on clique sur "Java application" puis sur "New" :
[newRun]
On obtient alors la fenêtre suivante :
[runArg]
En choisissant l'onglet arguments, on peut ajouter des arguments dans la boîte intitulée "Program arguments" :
[runArg1]

Par défaut, le répertoire de travail dans lequel le programme cherche les fichiers est le répertoire du projet. On peut le changer dans la boîte "Working directory" en décochant "Use default working directory", et en cliquant soit sur "Workspace" pour choisir un répertoire du workspace, soit "File System" pour choisir un autre répertoire.

Exception pendant l'exécution

Pendant l'exécution, il peut survenir une exception qui apparaît en rouge sous l'onglet console en bas de la fenêtre principale. Il est possible en cliquant sur l'une des lignes du stack trace d'accéder à l'endroit où a été levée l'exception. Par exemple, dans la capture suivante, en cliquant sur la ligne "at Hello.main(Hello.java:5)", eclipse saute à la ligne 5 du fichier Hello.java :
[runExn1]

Indentation du code

Pour qu'eclipse réindente le code que vous avez écrit (rappelons que le code doit normalement être écrit indenté correctement), sélectionner la partie à indenter, et cliquer sur Source -> Correct Indentation :
[indent]
[indent1]
[indent2]

Pour qu'eclipse reformatte complètement le code (pas seulement l'indentation, mais aussi plein d'autre choses décrite dans les préférences), sélectionner Source -> Format pour le fichier .java complet, ou Source -> Format Element pour juste une partie du programme.

Sources, classpath, dépendances ?

Un projet java, comme tout projet, peut nécessiter des bilbiothèques externes ou dépendre d'un autre projet. Sous eclipse, toutes ces dépendances constituent le build path. On le configure avec un clic droit sur le projet, puis "Build Path", puis "Configure Build Path...". Attention à "Remove from build path" qui risque de poser problème. En cas de maladresse, choisir "Use à source folder" (qui remplace "Remove from build path" sur le répertoire du projet (ou contenant les sources si vous en aviez défini un) pour revenir en arrière.
[buildpath]

Dépendre d'un autre projet

Sous l'onglet projet, vous pouvez dire qu'un projet a besoin des classes d'un autre (par exemple pour réutiliser des classes d'INF321 dans INF431). Il suffit d'ouvrir le projet à ajouter si ça n'est pas le cas, puis de clicker sur Add puis de cocher le projet que vous souhaitez utiliser. Il faut que tous les projets dont dépend le projet sur lequel vous travaillez soit ouvert pour que cela fonctionne. Par exemple, si INF431 dépend de INF321 et GrapheX, alors il faut que ces trois projets soient ouvert pour pouvoir travailler sur INF431. Dans le cas contraire, eclipse mets un message d'erreur "Project INF431 is missing required Java project: GrapheX" :
[missingProject]

Archives java, bibliothèques externes

En java, les bibliothèques externes se présentent sous la forme de .jar, qui sont des archives au format .zip qui contiennent les classes java compilées, c'est-à-dire les .class. Vous pouvez le créer comme vous créeriez un zip, mais eclipse peut le faire pour vous : Fichier -> Export, puis sélectionner JAR file dans la liste, puis Next>. Là, vous sélectionnez ce que vous souhaitez mettre (par défaut, tous les .class et toutes les ressources (i.e. ce qui n'est ni .java ni .class) sont sélectionnés. Il suffit d'entrer le nom de l'archive (par défaut, elle est mise dans le répertoire principal, mais on peut le changer avec Browse...) et de clicker sur Finish :
[exportJar]

Pour utiliser un jar externe dans un projet, sélectionner l'onglet Libraries dans le dialogue de "Configure Build Path". Si l'archive est dans le répertoire du projet, l'ajouter avec "Add JARs...", et sinon avec "Add External JARs...". Le premier ouvre une arborescence ne contenant que les .jar trouvés par eclipse dans le répertoire du projet (vide avec écrit no entries s'il y en a aucune), et le second une boîte de dialogue d'ouverture de fichier standard. Une fois la bibliothèque ajoutée, une icône correspondant est ajouté à la racine du projet mais le fichier .jar correspondant n'est pas copié pour autant dans le projet.

Problèmes rencontrés

Version du compilateur

Si eclipse déclare que des classes qui doivent être paramétrées ne le sont pas (par exemple HashMap ou LinkedList, à condition de les avoir importées), c'est probablement qu'il est configuré en java 1.4 (avant les types paramétrés). Pour changer cela, il faut sélectionner la page Java/Compiler, et sélectionner 5.0 dans Compiler Compliance Level (laisser le reste inchangé).
[preferencesCompiler]

Incohérence entre les fichiers sur le disque et en mémoire

Quand on modifie les fichiers à la main, ou que l'on en ajoute, il se peut qu'eclipse ne les voit pas. Dans ce cas, on peut lui demander de relire les fichiers du disque dur on faisant clic-droit puis Refresh sur la partie à rafraîchir, i.e. le projet :
[refresh]

Problème du compilateur

Il peut arriver que le compilateur interne d'eclipse ait des problèmes, et qu'il indique des erreurs qui n'existent plus. Quand le comportement d'eclipse paraît incorrect, utiliser l'article Clean... du menu Project, puis cliquer sur OK :
[clean]
[clean1]

Restaurer la disposition des onglets

À force de manipuler les onglets, la fenêtre principale peut ressembler à cela.
[resetperspective]

Dans ce cas, on peut rétablir la configuration d'origine en sélectionnant la perspective Java : soit le bouton en haut à droite, soit window -> open perspective -> Java, soit, si aucun des deux n'est disponible, window -> open perspective -> Other -> Java. Ensuite, window->reset perspective puis OK.
[resetperspective1]

Exécution de programmes en mode débogage

Exécuter un programme en mode débogage permet de voir ce qui se passe quand le programme s'exécute. Par exemple, on peut consulter l'état des variables et des champs ou regarder dans quelles fonctions le programme passe et avec quelles valeurs des paramètres. On peut aussi faire exécuter le programme pas à pas, ou fonction par fonction.

Pour pouvoir prendre la main sur la programme, il faut d'abord définir des breakpoints, c'est-à-dire les lignes de code où l'exécution doit s'arrêter pour permettre d'interagir avec la machine virtuelle. Cela se fait simplement en double-cliquant dans la marge. Cela fait apparaître un rond bleu [bullet].

Une fois les breakpoints définis, pour lancer un programme en mode débogage, on effectue un clic droit sur la classe contenant le main, puis on choisit Debug As... puis Java Applications :
[debug]

Pour utiliser le mode débogage, il faut passer dans la perspective debug (une perspective est un agencement de fenêtres particulier). Pour cela, on choisit Window -> Open perspective -> debug :
[debug1]
La perspective ouverte donne cet aspect à la fenêtre principale
[debug2]
L'onglet debug contient les threads lancés (pour les débutants, il n'y en a qu'un), l'onglet variable contient les variables et paramètres locaux avec leurs valeurs courante. L'onglet console permet d'interagir avec le programme. Par exemple, ici, une fois entré la valeur, on atteint le breakpoint, et la fenêtre devient celle-ci (comme on a entré 12, on a bien j=12) :
[debug3]

Quatre icônes permettent de contrôler l'exécution pas à pas. L'icône [stepOver] permet de passer à l'instruction suivante, [stepInto] permet d'entrer dans la méthode qui va être exécutée et [stepOut] permet de quitter la méthode courante pour rejoindre la méthode appelante. Pour continuer l'exécution jusqu'au prochain breakpoint, il suffit de cliquer sur [play]. Pour terminer le programme, cliquer sur le carré rouge [kill]. Enfin, pour interrompre le programme en train d'être exécuté, mais sans breakpoint, cliquer sur le bouton pause [pause]

Pour quitter le mode débogage, et retourner à l'ancienne perspective, on peut cliquer sur [java] en haut à droite de la fenêtre principale. Cette zone contient un raccourci vers les perspectives utilisées couramment.

Utilisation avancée

Assistance à l'écriture de programmes

Le raccourci Control-espace

Lorsque vous écrivez votre programme, eclipse peut vous aider à compléter ce que vous écrivez, en utilisant le raccourci clavier Control+Espace. Ce qu'il propose dépend d'où vous vous trouvez dans votre programme, et cela peut au début sembler déroutant. Il est d'ailleurs conseillé d'essayer régulièrement le raccourci pour voir ce qu'eclipse propose.

Exemple d'utilisation

Par exemple, si vous voulez utiliser la classe ArrayList du paquetage java.util, il faut normalement l'importer, puis l'utiliser. Ici, si vous tapez Arr puis control-espace, eclipse va proposer toutes les classes java disponibles qui commencent par Arr :
[types]
On obtient (notez qu'eclipse a ajouté la directive d'import) :
[types1]

Un autre exemple, si vous avez un objet l de type java.util.List, et que vous tapez list. puis control-espace, eclipse vous propose toutes les méthodes de List, avec un aperçu de la javadoc associée.
[methods]

Enfin, eclipse propose des raccourcis qui ajoutent du code prédéfini. Par exemple, main ajoute une méthode main, sysout ajoute un System.out.println.
[main]
[main1]
[sys]
[sys1]

Autocorrection

Pour un certain nombre de problèmes et d'avertissement, eclipse propose de modifier le code pour corriger l'erreur (ATTENTION, eclipse ne sera jamais intelligent à votre place, il faut regarder et choisir judicieusement les corrections automatiques). Des corrections sont disponibles quand l'icône d'erreur ou d'avertissement apparaît avec un petit ampoule ([logo] [logo1]). Cela se fait avec un clic simple dans la marge, puis un double-clic sur la correction à appliquer.

Par exemple, eclipse peut ajouter la déclaration d'une nouvelle variable locale :
[undeclared]
[undeclared1]
[undeclared2]

Eclipse peut ajouter les méthodes manquantes lors de l'implémentation d'une interface ou d'une classe abstraite :
[implement]
[implement1]
[implement2]

Commentaires semi-automatiques

Il est conseillé de commenter, même le minimum toutes les fonctions que l'on écrit. Il existe en java un système de génération de la documentation des programmes appelée javadoc. Les commentaires utilisés par javadoc sont entre /** et */. Quand, au dessus d'une méthode, vous commencez à taper /** puis entrée, eclipse commence à générer un squelette de documentation : il ne vous reste plus qu'à décrire la méthode, l'utilisation des paramètres, à écrire après les @param) et ce que retourne la méthode (sauf si c'est void), à écrire après le @return.

Pour générer la documentation, on peut soit utiliser le programma javadoc, soit demander à eclipse de la générer pour vous, avec l'article Generate Javadoc... du menu Project. Ceci ouvre la fenêtre suivante, où l'on vous demande de cocher la liste des classes dont il faut générer la documentation, et où elle doit être générée (on choisit en général le répertoire doc du projet). Si vous voulez que la documentation de tout soit généré (y compris les méthodes privées), cocher private à la place de protected.
[javadoc]

Sous-menus source et refactor

Avec le sous-menu source du menu contextuel, eclipse propose d'ajouter un certain nombre de choses, et notamment des constructeurs qui initialisent les champs, ou des getters et des setters. Par exemple, pour créer un classe Point contenant deux int, x et y, avec un constructeur et deux getters, il suffit de partir d'une classe contenant juste les deux champs, puis de demander à eclipse de générer le constructeur initialisant les champs (Generate constructor using fields) :
[fields]
[constructor]
[constructor1]
Les getters sont ajoutés avec Generate getters and setters, en sélectionnant seulement les getters en cliquant sur Select getters :
[getters]
[getters1]

À côté du sous-menu source, le sous-menu refactor permet de modifier du code existant. Par exemple, Rename permet de changer le nom d'un élément java (variable, méthode, classe) et de répercuter le changement partout où cet élément est utilisé.

Configurations avancées

Emplacement des fichiers .class et .java

Une des premières options qu'il est judicieux de changer concernant l'emplacement des fichiers java, et des fichiers compilés. En général, on préfère séparer ces derniers pour éviter d'avoir trop de fichiers dans le même répertoire, de confondre le .java et le .class, et de pouvoir distribuer plus facilement ses programmes.

Avec ces paramètres, pour exécuter le programme, soit on se positionne dans le dossier classes avant de lancer la commande java, soit on utilise l'option -cp (pour classpath) suivie du chemins vers le répertoire classes.

Pour cela, choisir la page de préférence Java/Build Path, puis cocher la case Folders, et laissant src pour les sources, mais en changeant bin en classes pour les classes (c'est le standard pour les programmes en java).
[preferencesBuildPath]

Codage de caractères des fichiers sources

Un des problèmes usuels de l'informatique est le codage des caractères (c'est le cas quand vous voyez fleurir les é et ê et autres dans les pages web). En particulier, windows, les unix et MacOS n'utilisent pas toujours le même (en fait jamais), et recopier des programmes d'une machine à l'autre peut poser des problèmes de conversion. Tant qu'il s'agit de programme, le problème n'apparaît pas puisque les codages sont souvent identiques pour les caractères non accentués. Le problème apparaît en général quand vous ajoutez des accents dans les chaînes de caractères.

Une des solutions est de forcer eclipse à utiliser le même codage pour toutes les plateformes. Cela se fait avec la page General/Editor, la boîte en bas, à gauche Text File Encoding". Il faut décocher default et cocher Other, puis choisir le codage (même si c'est le même par défaut, car le codage du système peut changer sans prévnir). Le codage désormais standard international est l'UTF-8 (qui permet d'avoir tous les caractères, comme א, ж, ố, ﻕ ou ε), mais vous pouvez aussi choisir ISO-8859-1 (appelé aussi latin1) ou ISO-8859-15 (appelé aussi latin9, qui permet, par rapport au latin1, d'avoir œ Œ et €).
[locale]

Notification d'erreur ou maladresse de programmation

On peut choisir de manière assez précise quel warning eclipse soulève, voire les transformer en erreur. Cela se fait avec la page Java/Build Path/Error Warnings.
[preferencesErrorWarning]

Quand on modifie des valeurs, eclipse indique qu'il doit recompiler les projets par la boîte de dialogue suivante :
[fullBuildDialog]

Les réglages par défaut sont satisfaisant, sauf si vous utilisez la version 3.2, une nouvelle option fort utile, qui lève une erreur quand on utilise un type paramétré sans le paramètre (on appelle cela un raw type). L'option est la suivante :
[Generic3.2]

Changement du style du code auto-généré

Quand on crée de nouvelles classes, eclipse ajoute souvent des lignes de code. Ce qu'il ajoute est entièrement paramétrable avec la page de configuration Java/Code Style/Code Templates. On peut entrer du texte ou des variables dont le sens dépend du contexte. On change une valeur avec le bouton Edit, dans la fenêtre qui s'ouvre le bouton insert variable donne la liste des variables et leurs sens (vous l'exemple ci-dessous).
[preferencesCodeTemplate]

Par exemple, pour changer le code d'ajout de clause try/catch pour qu'il encapsule l'exception plutôt que de d'afficher le stack trace, on clique sur edit, et on obtient  :
[preferencesCodeTemplateDialog]
Ici, la variable exception_var est le nom de la variable qui contient l'exception attrapée

Une fois la modification effectuée, on obtient :
[preferencesCodeTemplate1]