Eclipse

Un IDE est un environnement complet qui permet de travailler plus vite en regroupant de multiples outils de développement dans une même interface.

Eclipse est l'IDE java le plus utilisé au monde. Il est extrêmement populaire car il est très complet, modulaire et gratuit.

Il dispose d'une myriade de plugins et est aussi la base (eclipse rcp) pour des environnements de développement spécialisés.

En téléchargement, il existe plusieurs bundles : eclipse classic + une sélection de plugins.

L'une des 2 versions ci-dessous convient pour les manipulations à venir :

Les autres IDEs les plus utilisés sont :

Le but de ce tp est de se familiariser avec l'interface d'eclipse.

Workspace

Au démarrage d'éclipse, on peut choisir son workspace.

Le workspace est le répertoire de travail d'eclipse qui contient tous les projets manipulées.

Il est possible d'avoir plusieurs workspaces et de passer de l'un à l'autre mais cela est rarement nécessaire. Les capacités d'organisation au sein d'un workspace étant généralement suffisantes.

Perspectives et vues

Comme n'importe quel IDE, eclipse a sa façon de nommer les différents éléments de son interface.

Cette nomenclature est importante car elle permet de communiquer en utilisant les mêmes termes.

Le workbench est la fenêtre principale. Elle contient les menus, les vues, les éditeurs et des zones d'information.

Les vues et les perspectives sont accessible via le menu Window.

Une vue est une sous partie de spécialisé l'interface : explorateur de projet, editeurs, serveurs, explorateur de repository svn...

Il existe beaucoup de vues au sein d'eclipse.

Les vues sont organisées en panneaux tabulés au sein du workbench

Une perpective est une distribution particulière de vues dans le workbench : java, debug, database explorer,

En changeant de perspective, on passe donc à une organisation adaptée à la tâche en cours.

Les éditeurs occupent généralement la partie centrale du worbench et permettent d'éditer les contenus.

Préférences

Les préférences sont accessibles via le menu Window.

Elles permettent de régler tous les aspects de l'IDE : formattage des sources, environnement java, serveurs...

Le moteur de recherche dans les préférences est très puissant et permet de trouver une option cachée dans un sous panneau d'un sous menu.

Plugins

Les plugins sont un élément fondamental d'éclipse. Eclipse est un conteneur de plugin.

Les bundles viennent avec beaucoup de plugins pré installés et le menu Help > Eclipse MarketPlace permet d'en installer de nouveaux.

Un projet java

Afin de tester quelques fonctionnalités d'eclipse, nous allons créer un projet java.

Un projet java se crée via le menu File > New > Project... et en choisissant le type Java > Java Project.

On entre un nom de projet "test" et on clique sur finish.

Un nouveau projet "test" est donc disponible dans le workspace et un répertoire src contiendra les sources java.

Une classe

En faisant un click droit sur le répertoire, on peut créer une classe java Person dans le package fr.test

On obtient le code suivant :

package fr.test;

public class Person {

}

Getters et Setters

On ajoute les attributs suivants dans la classe.

private String firstname;

private String lastname;

Eclipse est capable de générer les getters et setters pour ces attributs. Il suffit de faire un click droit dans l'éditeur et d'utiliser le menu Source > Generate Getters and Setters...

public String getFirstname() {
    return firstname;
}

public void setFirstname(String firstname) {
    this.firstname = firstname;
}

public String getLastname() {
    return lastname;
}

public void setLastname(String lastname) {
    this.lastname = lastname;
}

Les getters et setters sont aussi appelés accesseurs.

toString

La méthode toString() est la méthode qui transforme un Object en chaîne de caractères. Elle sert principalement à faire du débug car pour la serialisation il existe des mécaniques bidirectionnelles (objet <-> string) plus complètes.

Eclipse peut également générer cette méthode via le menu contextuel Source > Generate toString()...

@Override
public String toString() {
    return "Person [firstname=" + firstname + ", lastname=" + lastname + "]";
}

equals et hashCode

Ces 2 méthodes marchent en couple et sont capitales.

Le contrat et le lien entre ces méthodes dépasse le cadre d'un simple exercice sur eclipse mais une description détaillée est disponible dans le chapitre 3 de effective java

Les méthodes equals et hashCode permettent de comparer des objets 2 à 2. Elles sont particulièrement utiles pour des mécaniques de cache ou des tables de hash.

Elles sont difficiles à bien implémenter et une mauvaise implémentation peut être fatale.

Avec eclipse, il suffit de demander la génération de ces méthodes via Source > Generate hashCode() and equals()...

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((firstname == null) ? 0 : firstname.hashCode());
    result = prime * result + ((lastname == null) ? 0 : lastname.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (firstname == null) {
        if (other.firstname != null)
            return false;
    } else if (!firstname.equals(other.firstname))
        return false;
    if (lastname == null) {
        if (other.lastname != null)
            return false;
    } else if (!lastname.equals(other.lastname))
        return false;
    return true;
}

Les capacités de génération d'eclipse vont bien au delà de ces simples exemples. Nous aurions pu faire tout ce code à la main et parfois cela est nécessaire.

Cependant, java est un language verbeux et chaque fois que cela est possible, il est bon de pouvoir compter sur l'IDE.

main

On va maintenant créer une classe avec une méthode main.

package fr.test;

public class Main {
    public static void main(String[] args) {

    }
}

C'est un point de départ obligé pour toute application java.

En pratique, dans des environnements managés, cette méthode est déjà implémentée pour nous.

Afin de la tester un peu, on ajoute une écriture dans la sortie standard (stdout).

System.out.println("Hello world !");

On peut lancer cette méthode via le menu contextuel de la classe.

On peut utiliser notre class Person depuis le main.

Person person = new Person();

person.setFirstname("alex");
person.setLastname("luthor");

System.out.println(person);

Le menu Debug As permet d'exécuter le même code en placant des points d'arret et en maitrisant l'éxécution pas à pas.

Refactoring

Les IDEs java profitent du fort typage du language afin d'offrir de grandes capacités de refactoring.

Imaginons que nous souhaitions renommer la classe Person en People.

Un click droit sur la classe et on accède au menu Refactor > Rename... qui permet de faire le changement de nom.

La classe main a été modifiée en fonction.

People person = new People();

person.setFirstname("alex");
person.setLastname("luthor");

System.out.println(person);

Encore une fois, les capacités d'eclipse dépassent amplement cet exemple simple. Son éditeur de code et ses outils de refactoring sont très puissants.

Navigation

Les capacités de navigation au sein de l'IDE sont nombreuses. Voici quelques façons de trouver ce que l'on cherche :

Par exemple, si on tape control-shift-T puis "People", on peut ouvrir rapidement le fichier contenant la classe sans utiliser la souris.

Plus de raccourcis

Les raccourcis clavier sont indispensables afin d'être plus productif. En voici quelques uns :

Il est facile de trouver des listes de raccourcis sur le web. Par exemple, en suivant ce lien