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, dans un premier temps, on utilisera la version 1.4 de java).

La fenêtre de configuration s'obtient dans le menu Window > 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.

La première partie des TD de J1IN4W01 utilise la version 1.4 de java. Il faut configurer eclipse pour qu'il utilise java 1.4 par défaut. Pour changer cela, il faut sélectionner la page Java > Compiler, et sélectionner 1.4 dans Compiler compliance level (laisser le reste inchangé).

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.

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

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

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

Les programmes java d'eclipse s'organisent en projets. Un projet va contenir un certain nombre de fichiers java (eux-même organisés sous la forme de paquetages). Dans le cadre de l'UE J1IN4W01, il vous est demandé de faire un projet par planche de TD dans le workspace workspaces/J1IN4W01.

Comme vu dans la section Premier projet, Hello world, pour créer un nouveau projet, cliquer sur File > New > Java Project :

Après 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.

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 en pdf), 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é.

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 considérant qu'une classe TC (imaginaire) permet de lire des entiers depuis le clavier, on peut écrire et lancer le programme suivant :

en entrant les deux valeurs, on obtient :

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 :

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

On obtient alors la fenêtre suivante :

En choisissant l'onglet arguments, on peut ajouter des arguments dans la boîte intitulée "Program arguments" :

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.

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.

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 :

On obtient (notez qu'eclipse a ajouté la directive d'import) :

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.

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.

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

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

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. Par exemple, en control-cliquant sur ArrayList, eclipse ouvre :

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.

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

Les getters sont ajoutés avec Generate getters and setters, en sélectionnant seulement les getters en cliquant sur Select getters :

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

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

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 :

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

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.