<< | EclipseIndex | Exemple développé de l'utilisation d'Eclipse >>

Plan (hide)

  1.   1.  Installation
  2.   2.  Éléments de base
    1.   2.1  Le workspace
    2.   2.2  Configurations
  3.   3.  Un premier projet
  4.   4.  Mise en forme de votre code
  5.   5.  Échanges avec le programme
    1.   5.1  Utilisation de args[]
    2.   5.2  Saisie de données
  6.   6.  Exécution, exception debogage
    1.   6.1  Exceptions
    2.   6.2  Débogage
  7.   7.  Utiliser une librairie jar avec Eclipse
  8.   8.  Utiliser une dépendance maven avec Eclipse

1.  Installation

Les copies d'écran peuvent vous sembler trop petites vous pouvez toujours les voir dans la taille originale avec un clic droit et afficher l'image.

Si tout se passe bien normalement à l'université c'est déjà installé, cependant si vous voulez l'installer sur votre machine personnelle, il suffit d'aller de vous rendre sur http://www.eclipse.org/downloads/ et choisir la version en fonction de votre système d'exploitation (la sélection se fait normalement automatiquement).

2.  Éléments de base

L'interface d'eclipse repose sur la notion de perspective qui regroupe un ensemble de view. Une perspective est donc un ensemble de vues qui permet de travailler sur un thème donné. On trouve ainsi la perspective java pour, en s'en douterait, développer en java, ou encore la perspective debug pour le déverminage, sans oublier la perspective resource qui est celle par défaut qui permet d'explorer l'espace de travail (workspace). Pour changer de perspectives il suffira d'aller dans le menu : 

 Window → Open Perspective

2.1  Le workspace

La première chose donc à maîtriser est le workspace, dans cet espace vous pouvez définir des projets que vous souhaitez créer et gérer et qui peuvent par exemple correspondre aux différents TD. Les projets regroupent les fichiers que vous avez créés.

Au lancement d'eclipse vous donnez le nom du workspace dans lequel vous voulez travaillez /home/damien/workspace/PSOO par exemple. Il est alors créé s'il n'existe pas. Vous obtenez ensuite l'écran d'accueil initial d'eclipse.

Il vous suffit alors de cliquer sur workspace en haut à droite. Pour arriver à l’environnement de travail dans lequel nous allons faire quelques petites configurations au préalable.

2.2  Configurations

Le menu Preferences vous permet de configurer eclipse comme par exemple la version java que vous utilisez ou les mises à jour automatiques. Vous pouvez également configurer le dictionnaire. 

 Window → Preferences

Choix du compilateur

Il faut choisir au moins java 1.8

Choix de la version du compilateur

Mise à jour

3.  Un premier projet

Nous allons essayer de changer du hello world traditionnel (encore que !), pour cela je vous propose d'afficher la date du jour. On commence par créer le projet choisissant File → New → Java Project

Vous donnez un nom à votre projet

qui apparaît alors dans package explorer

Tout programme java comporte au moins une classe, nous allons créer une classe principale qui comportera la méthode main().

Dans la fenêtre qui s'ouvre, on donne le nom de la classe, DateDuJour qui sera notre classe principale, et on coche la case indiquant que l'on souhaite qu'elle contienne une méthode main().

Eclipse a alors créé un squelette de la classe (stub en anglais) qu'il faut alors compléter.

On fait appel à la méthode println() qui affiche une chaîne de caractère qui lui est passée en argument, à l'opérateur de concaténation + et on créé un objet Date qui est converti en chaîne de caractère. Eclipse nous indique alors qu'il y a un problème à l'aide de la croix rouge dans la marge et nous propose des solutions.

Après correction, cela donne

Pour exécuter la classe, clic-droit sur le fichier contenant la méthode main(), puis Run As → Java Application.

L'affichage de l'exécution se fait sous l'onglet console.

Vous pouvez tester une version plus aboutie :

import java.text.SimpleDateFormat;
import java.util.Date;


public class DateDuJour {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                SimpleDateFormat formater = new SimpleDateFormat("dd MMMMM yyyy GGG, HH:mm:ss");
                System.out.println("Nous sommes le " + formater.format(new Date()));
        }
 }
[$[Get Code]]

4.  Mise en forme de votre code

Pour faciliter la lecture de votre code, vous devez mettre en forme votre code en indentant de façon à bien dégager les blocs d'instruction. Eclipse vous aide à réaliser cela, il vous suffit d'aller dans Source → Correct indentation. Vous avez également la possibilité de le faire sur une partie du programme Source → Format Element ou sur tout le fichier Source → Format.

5.  Échanges avec le programme

Nous n'abordons pas ici, les échanges avec le programme par l'intermédiaire d'interaction fenêtre/souris par exemple, ou encore à l'aide d'un fichier. Les deux points que nous souhaitons développer sont les paramètres transmis au programme par l'intermédiaire de la ligne de commande et l'utilisation de la console pour fournir des données par exemple.

5.1  Utilisation de args[]

Il est possible de passer un nombre quelconque de paramètres à votre programme java par l'intermédiaire du tableau de chaînes de caractères constantes args[]. On va par exemple passer un nom, il ne devra alors y avoir qu'une seule chaîne dans le tableau args.

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDuJour {

        /**
         * @param args
         *            : nom de l'utilisateur
         */
        public static void main(String[] args) {
                if (args.length != 1) // Plus d'un argument ou pas d'argument
                        System.exit(-1);
                else {
                        SimpleDateFormat formater = new SimpleDateFormat(
                                        "dd MMMMM yyyy GGG, HH:mm:ss");
                        System.out.println("Bonjour " + args[0] + " nous sommes le "
                                        + formater.format(new Date()));
                }
        }
 }
[$[Get Code]]

Si vous exécuter ce programme tel quel vous sortirez sur le System.exit(-1), il faut donc fournir l'information à votre programme. En ligne de commande traditionnelle cela se fait par : 

 % java DateDuJour Damien
 Bonjour Damien nous sommes le 02 octobre 2013 ap. J.-C., 11:16:21

args[0] contient alors la chaîne de caractère"Damien". Avec eclipse, vous sélectionnez au niveau du Package Explorer le fichier .java dans lequel se trouve votre méthode main(), ensuite Run → Run Configurations ... → , vous obtenez une fenêtre comme celle ci-dessous :

Vous choisissez l'ongle Arguments etdans le cadre Program arguments vous fournissez votre valeur "Lucien", par exemple. Il ne vous reste plus qu'à lancer l'exécution par l'intermédiaire du bouton run. En passant vous pouvez remarquer que l'on a commenté le code en particulier avant la méthode main() avec entre /** et */ ce qui génère une javadoc qui est accessible avec l'onglet correspondant dans la zone du bas.

5.2  Saisie de données

Cela ne pose pas de problème depuis l'apparition des classes Scanner et Formatter.

/**
 * Classe servant d'exemple d'utilisation d'eclipse
 * @author Damien Olivier
 * @version 1.2
 */
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class DateDuJour {

        /**
         * Affiche la date du jour et l'heure
         * @param args
         *            : nom de l'utilisateur
         * @see Scanner SimpleDateFormat                        
         */
        public static void main(String[] args) {
                if (args.length > 1) // Plus d'un argument
                        System.exit(-1);
                else {
                        String prenom;
                        if (args.length == 0) { // Pas d'argument on le demande à l'utilisateur
                                Scanner sc = new Scanner(System.in);
                                System.out.print("Entrez votre prénom : ");
                                prenom = sc.nextLine();
                        } else
                                prenom = args[0];
                        SimpleDateFormat formater = new SimpleDateFormat(
                                        "dd MMMMM yyyy GGG, HH:mm:ss");
                        System.out.println("Bonjour " + prenom + " nous sommes le "
                                        + formater.format(new Date()));
                }
        }
 }
[$[Get Code]]

Il ne vous reste plus qu'à donner votre prénom.

6.  Exécution, exception debogage

Nous avons déjà vu comment lancer l’exécution simple d'un programme ou avec des paramètres, mais que se passe t-il en cas d'erreurs ? Certaines erreurs génèrent une exception.

6.1  Exceptions

L'exception apparaît en rouge dans la 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.

6.2  Débogage

Vous serez forcément confronté un jour ou un autre à un programme qui plante lamentablement sans raison évidente. Dans ce cas, il faut vous armer de courage et soit :

  1. relire votre code en espérant trouver l'erreur, dans tous les cas ce n'est jamais inutile ;
  2. truffer votre code de Systeme.err.println(....) afin de trouver l'endroit qui pose un problème, c'est fastidieux et attention à la bufferisation des entrées/sorties ;
  3. utiliser un débogueur exécute votre code et permet de suspendre son exécution, la reprendre, afficher le contenu de variables, etc.... C'est cette solution que vous propose eclipse et que nous allons examiner.

Considérons le programme suivant (faux et idiot) qui calcule la somme d'une suite de termes. La première classe UtiCompteur.java

package demo.debug;

public class UtiCompteur {

        public static void main(String[] args) {
                Compteur compteur = new Compteur(9);
                compteur.compte();
                System.out.println("Calcul de la somme des termes : "
                                + compteur.getResultat());
        }

}
[$[Get Code]]

La classe Compteur.java

package demo.debug;

public class Compteur {
        private int borne;
        private int resultat = 0;

        public Compteur(int val) {
                borne = val;
        }

        public int getResultat() {
                return resultat;
        }

        public void compte() {
                for (int i = 0; i != borne; i++) {
                        resultat += ++i;
                }
        }

 }
[$[Get Code]]

Si vous exécuter ce programme avec une valeur de borne impaire 9 Compteur compteur = new Compteur(9); par exemple cela ne fonctionne pas, par contre cela fonctionne parfaitement avec une valeur paire. Dans le premier cas il faut arrêter le programme avec le carré rouge visible durant l'exécution.

Nous allons maintenant nous lancer dans le débogage de ce programme. D'une façon générale cela consiste à consulter la valeur des champs, des variables, dans quelles méthodes on passe et avec quels arguments. Il est également possible d’exécuter le programme méthode par méthode ou même pas à pas.

Pour prendre la main durant l'exécution du programme, on définit des points d'arrêt (breakpoint). Ces points permettent alors d'interagir avec la machine virtuelle java. Un façon simple de poser un point d'arrêt consiste à double cliquer dans la marge ce qui fait apparaître un joli rond bleu .

Nous avons donc placé un point d'arrêt sur la ligne Compteur compteur = new Compteur(9);. Il suffit maintenant de lancer le débogueur, pour cela sélection clic droit sur le fichier java qui doit être exécuté et choisissez Debug As → Debug Configuration, une fenêtre s'ouvre sélectionnez Java Application et ensuite cliquez sur debug. Eclipse vous propose alors d'ouvrir la perspective de débogage.

Cela ressemble à cela :

Vous pouvez ensuite contrôler l'exécution pas à pas.

F5Permet d'entrer dans la méthode qui va être éxécutée
F6Permet de passer à l'instruction suivante
F7Permet de quitter la méthode courante pour rejoindre la méthode appelante
F8Permet de continuer l'exécution jusqu'au prochain point d'arrêt
CTRL F2Stop

Vous pouvez revenir à la perspective java grace à .

Revenons au programme tel que nous l'avons proposé, notre programme ne fonctionne donc pas correctement. Nous allons utiliser le débogueur pour trouver l'erreur. Pour cela plaçons un point d'arrêt sur la ligne compteur.compte(); et ensuite lançons le débogage. On rentre par dans la méthode compte() de la classe compteur.java et on suit alors le s variables manipulées : borne, resultat et i. On constate rapidement que quand on "retourne" en début la boucle la valeur de i est toujours paire donc si la borne est impaire la boucle est infinie.

C'est évidemment un mauvais exemple. On ne touche jamais à l'intérieur d'une boucle for à la variable de boucle et on écrit les conditions d'arrêt les plus larges possibles.

7.  Utiliser une librairie jar avec Eclipse

Vous pouvez vouloir utiliser une librairie jar avec Eclipse. Je vais illustrer mon propos avec la librairie JMathPlot qui permet de tracer simplement des courbes. La première chose à faire est de récupérer les fichiers jar :

Comme précédemment vous créez un projet Tracé de courbe, par exemple.

ensuite vous cliquez sur next, vous choisissez l'onglet Libraries ensuite Add External JARs...

et vous fournissez en entrée vos jar. Vous n'avez plus qu'à écrire votre classe UnBeauSinus et exécuter le tout.

package demo.courbe;

import javax.swing.JFrame;

import org.math.plot.Plot2DPanel; // Connu grâce au jar

public class UnBeauSinus {

        private static double fonction(double x) {
                return Math.sin(x);
        }

        private static double[] fonction(double[] x) {
                double[] r = new double[x.length];
                for (int i = 0; i < x.length; i++)
                        r[i] = fonction(x[i]);
                return r;
        }

        private static double[] increment(double x0, double pas, double x_n) {
                int nbValeurs = (int) ((x_n - x0) / pas) + 1;
                double[] r = new double[nbValeurs];
                for (int i = 0; i < nbValeurs; i++)
                        r[i] = x0 + pas * i;
                return r;
        }

        public static void main(String[] args) {
                double[] x = increment(0.0, 0.2, 20.0); // x = 0.0:0.2:20.0
                double[] y = fonction(x);

                // On crée un Panneau pour tracer la courbe
                Plot2DPanel plot = new Plot2DPanel();

                // Position de la légende
                plot.addLegend("EAST");
                // On trace
                plot.addLinePlot("sin(x)", x, y);

                // on met le Plot2DPanel dans une JFrame
                JFrame frame = new JFrame("Tracé de sin(x)");

                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setSize(600, 600);
                frame.add(plot);
                frame.setVisible(true);
        }

}
[$[Get Code]]

8.  Utiliser une dépendance maven avec Eclipse

<< | EclipseIndex | Exemple développé de l'utilisation d'Eclipse >>