Table des matières

Introduction

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.

Concept

Au fur et à mesure que vous programmez, eclipse compile automatiquement le code que vous écrivez, en soulignant en rouge ou jaune les problèmes 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. Il est possible de spécifier la version d’eclipse que vous souhaitez lancer via les commandes eclipse-luna, eclipse-mars, eclipse-neon ou eclipse-oxygen. 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. Normalement, la page http://www.eclipse.org/downloads choisit automatiquement la bonne version.

Premiers Contacts

Workspace

Le workspace est le répertoire dans lequel sont stockés :

Afin d’éviter de reconfigurer eclipse plusieurs fois, on évite en général de multiplier les workspaces. Nous préconisons d’utiliser un workspace par cours, et un projet par TD. Par exemple, le workspace du cours 4TIN509U sera ~/workspaces/4TIN509U. Et ainsi de suites. Noter que le répertoire contenant l’ensemble des workspaces s’appelle ~/workspaces avec un s.

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

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 (sans s), et peut être changé, sans créer le répertoire à l’avance. Par exemple, pour le cours 4TIN509U, on choisira la workspaces/4TIN509U comme workspace :

workspace

Une fois le workspace choisi, le programme s’initialise sur la fenêtre suivante (ou une du même style) :

Pour commencer à travailler, il suffit de fermer l’onglet “Welcome” ou cliquer sur “Workbench”.

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 en choisissant File > New > Java 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 le nom du projet, par exemple td_0. 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]

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

[helloWorld1]

Ensuite, en cliquant avec le bouton droit sur le projet, on sélectionne New > Class. Dans la fenêtre qui s’ouvre, on indique le nom de la classe, HelloWorld, et on coche la case indiquant que l’on souhaite qu’elle contienne une méthode main :

[helloWorld3]

Eclipse crée le squelette de la classe (stub en anglais). Notez le commentaire TODO rappelé dans la marge par l’icône [task]

[helloWorld4]

Il ne reste qu’à compléter la méthode main :

[helloWorld5]

Pour exécuter la classe, clic-droit sur le fichier .java, puis Run As > Java Application. L’affichage de l’exécution s’effectue sous l’onglet console en bas de la fenêtre principale :

[helloWorld7]

Incorporations de sources existantes

Pour incorporer des sources (des .java) existantes, la solution la plus commode consiste à utiliser à bon escient le copier-coller.

Prenons, par exemple, le code suivant:

/*
  Swap Numbers Java Example
  This Swap Numbers Java Example shows how to
  swap value of two numbers using java.
*/

public class SwapElementsExample {
  public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    System.out.println("Before Swapping");
    System.out.println("Value of num1 is :" + num1);
    System.out.println("Value of num2 is :" +num2);
    //swap the value
    swap(num1, num2);
  }

  private static void swap(int num1, int num2) {
    int temp = num1;
    num1 = num2;
    num2 = temp;

    System.out.println("After Swapping");
    System.out.println("Value of num1 is :" + num1);
    System.out.println("Value of num2 is :" +num2);
  }
}

Après avoir sélectionner le code (e.g. depuis cette page ou d’un sujet de TD), on copie ce dernier dans le presse-papier (CTRL+C). On clique (clique gauche sur le nom du projet) et on colle le contenu du presse-papier (CTRL+V). Un fichier avec le nom de la classe est automatiquement créé et ajouté au projet sélectionné.

[copier-coller2]

Exécution du programme

Comme vu dans la section Premier projet, Hello world, pour 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

Il est alors possible d’intéragir avec le programme sous l’onglet “Console”, en bas de la fenêtre principale. Par exemple, en saisisant des valeurs attendues par le programme sur l’entrée standard (le clavier par défaut).

Interruption du programme

Notez le carré rouge visible pendant l’exécution. En cliquant dessus, on peut interrompre le programme, par exemple s’il est bloqué 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 configurations. Si le 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 :

[runArg]

En choisissant l’onglet arguments, on peut ajouter des arguments dans la boîte intitulée Program arguments, comme par exemple l’argument toto :

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

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 méthode le programme passe et avec quelles valeurs des paramètres. On peut aussi faire exécuter le programme pas à pas, ou méthode par méthode.

Pour pouvoir prendre la main sur la programme, il faut d’abord définir des points d’arrêts (breakpoints en anglais), 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. 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. 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, la variable locale x vaut 17 et le premier élément du tableau args vaut toto :

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

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]

En choisiant une tableau de chaîne de caractères (Java > 1.5). 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.

Autocorrection

Pour un certain nombre de problèmes et d’avertissements, 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 une 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]

Eclipse peut ajouter les méthodes manquantes lors de l’implémentation d’une interface ou d’une classe abstraite.

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

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.

Eclipse permet d’accéder directement à la définition d’un élément java (classe, méthode, champ, variable…). Pour cela, il suffit d’appuyer sur control, puis de pointer l’élément qui apparaît alors en bleu souligné, et de cliquer dessus. Ceci permet d’accéder à la définition, dans le fichier java correspondant si c’est dans une classe que nous avons défini, ou en utilisant les sources de JDK sinon.

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 en sélectionant Project > 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 entiers x et y, avec un constructeur et deux getters, il suffit de partir d’une classe contenant juste les deux champs :

[fields]

Demander ensuite à eclipse de générer le constructeur initialisant les champs en sélectionant Source > Generate constructor using fields :

[constructor]

Puis enfin de générer les getters et setters en sélectionant

[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

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 via la page General > Workspace, dans 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]

Problèmes rencontrés

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.

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 > Perspective > Java, soit, si aucun des deux n’est disponible, Window > Perspective > Open perspective… > Other… > Java. Ensuite, Window > Perspective > Reset perspective… puis OK.

[resetperspective1]