Programmation d'un modèle de graphe avec l'environnement de développement intégré Eclipse

Serge Bachmann

L'environnement de développement « Eclipse » est utilisé pour définir un modèle de graphe. Une instance de ce modèle est créée puis testée. Ce document donne quelques rudiments de l'utilisation de l'IDE. Pour plus de précisions, le lecteur se reportera à la littérature abondante sur le sujet.

Pour réagir à cet article, un espace de dialogue vous est proposé sur le forum Commentez

- Titre : Programmation d'un modèle de graphe avec l'environnement de développement intégré Eclipse

- Auteur : Serge Bachmann

- Parution : 25 janvier 2012

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2011 Serge Bachmann. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- I-A. Spécification

- I-B. Lancement de la plate-forme Eclipse

- I-C. Mise en place du projet

- II. L'application

- II-A. Création du modèle

- II-A-1. Aide fournie par l'éditeur Java

- II-B. Création d'un graphe

- II-C. Test du graphe

- III. Test du code

- IV. Conclusions

- V. Licence

I - Introduction

I-A - Spécification

À partir d'un modèle de graphe, nous allons créer une instance de graphe.

Un graphe est constitué d'un ensemble de Nœuds et d'Arcs. Chaque Arc est constitué d'un Nœud Origine et d'un Nœud Extrémité. Un nom est associé aux Nœuds et aux Arcs.

I-B - Lancement de la plate-forme Eclipse

Double-cliquer : ou le raccourci vers cet exécutable si vous l'avez créé dans le répertoire destiné à recevoir les « workspaces ». La plate-forme « Eclipse » est lancée :

On sélectionne le « workspace » :

Cliquer « OK », le workspace est créé :

La plateforme « Eclipse » s'affiche, fermer la fenêtre « Welcome » et quelques vues que nous n'utiliserons pas : Task List, Outline, Problems, Javadoc, Declaration.

On obtient un « Workbench » simplifié :

I-C - Mise en place du projet

Sous « Eclipse » tout développement se fait sous un projet. Pour créer un « Java Project » faire :

Dans la fenêtre « New Java Project » - Create a Java Project », nommer le projet :

Cliquer « Finish ».

Le projet est créé :

II - L'application

II-A - Création du modèle

Pour recevoir le modèle, on crée le « package » « modeleGraphe ». Faire un clic droit sur « src » et dans le menu contextuel désigner « New > Package »

Dans « New Java Package - Java Package » nommer le « package » :

Cliquer « Finish ». Le « package » est créé :

Nous allons créer la classe « Noeud ». Faire un clic droit sur le « package » « modeleGraphe » et dans le menu contextuel désigner « New > Class »

Dans la fenêtre « New Java Class - Java Class » nommer la classe, cliquer « Finish ».

La classe est créée :

On crée de même les classes « Arc » et « Graphe » :

On édite ces classes :

La classe « Noeud » :

package modeleGraphe;

import java.util.LinkedList;
import java.util.ListIterator;

publicclass Noeud {
String nom;
public String getNom() {
returnnom;
}

Graphe graphe;

public Noeud (String nom, Graphe graphe){
this.nom = nom;
this.graphe = graphe;
graphe.listeNoeuds.add(this);
}

public String toString(){
returnnew String("   noeud: "+ this.getNom());
}

public Object[] getChildren( Noeud noeud){
LinkedList<Noeud> children = new LinkedList<Noeud> ();
ListIterator<Arc> liArc = graphe.listeArcs.listIterator();
while (liArc.hasNext()){
Arc arcCourant = liArc.next();
if (arcCourant.getNoeudOrigine().getNom().equals(noeud.getNom())){
children.add(arcCourant.getNoeudExtremite());
}
}
return children.toArray();
}

public Boolean hasChildren(){
return (getChildren(this).length != 0 );
}
}

La classe « Arc » :

package modeleGraphe;

import java.util.ListIterator;

publicclass Arc {
Noeud noeudOrigine;
public Noeud getNoeudOrigine() {
returnnoeudOrigine;
}

Noeud noeudExtremite;
public Noeud getNoeudExtremite() {
returnnoeudExtremite;
}

public Arc(String nomNoeudOrigine, String nomNoeudExtremite, Graphe graphe){

// recherchenoeudorigine par son nom
ListIterator<Noeud> liNoeuds = graphe.listeNoeuds.listIterator();
Boolean trouveOrigine = false;
while (liNoeuds.hasNext()&&!trouveOrigine) {
Noeud noeudCourant = liNoeuds.next();
if (nomNoeudOrigine.equals(noeudCourant.getNom())){
noeudOrigine = noeudCourant;
trouveOrigine = true;
}
}
// recherchenoeudextremite par son nom
liNoeuds = graphe.listeNoeuds.listIterator();
Boolean trouveExtremite = false;
while (liNoeuds.hasNext()&&!trouveExtremite) {
Noeud noeudCourant = liNoeuds.next();
if (nomNoeudExtremite.equals(noeudCourant.getNom())){
noeudExtremite = noeudCourant;
trouveExtremite = true;
}
}
if (trouveOrigine && trouveExtremite) {
graphe.listeArcs.add(this);
} else {
// message d'erreur
StringBuffer erreur = new StringBuffer("Erreur arc: ("+nomNoeudOrigine
+" -> "+nomNoeudExtremite+")\n   ");
if (!trouveOrigine ) erreur.append(nomNoeudOrigine + "? ");
if (!trouveExtremite ) erreur.append(nomNoeudExtremite + "? ");
System.out.println(erreur);
}

}

public String toString(){
returnnew String("   arc: ( "
+ this.getNoeudOrigine().getNom()
+ " -> "
+ this.getNoeudExtremite().getNom()
+ " )"
);
}

}

La classe « Graphe » :

package modeleGraphe;

import java.util.LinkedList;
import java.util.ListIterator;

publicclass Graphe {
LinkedList<Noeud> listeNoeuds = new LinkedList<Noeud> ();
LinkedList<Arc> listeArcs = new LinkedList<Arc> ();

public Object[] getNoeuds(){
returnlisteNoeuds.toArray();
}

public Object[] getArcs(){
returnlisteArcs.toArray();
}

public String toString(){
StringBuffer texte = new StringBuffer("*** graphe ***\n");
ListIterator<Noeud> liNoeud = this.listeNoeuds.listIterator();
while (liNoeud.hasNext()){
Noeud noeudCourant = liNoeud.next();
texte.append(noeudCourant.toString()+"\n" );
}
ListIterator<Arc> liArc = this.listeArcs.listIterator();
while (liArc.hasNext()){
Arc arcCourant = liArc.next();
texte.append(arcCourant.toString()+"\n" );
}
return texte.toString();
}
}

Faire une sauvegarde générale : .

On obtient dans le « package explorer » :

II-A-1 - Aide fournie par l'éditeur Java

Lors de l'édition en plaçant le curseur sur la méthode «toString() de la classe « Graphe » on obtient des renseignements sur le rôle de la méthode :

Dans la classe « Noeud » méthode « getChildren(...). Lors de la saisie de la dernière ligne de la méthode, on tape « return child » puis « CTRL » + « Space » l'éditeur fait un ensemble de propositions :

Dans la liste ci-dessus, on choisit la variable locale « children » on obtient :

À la suite de « children » on tape « . » on obtient la liste des méthodes applicables à l'objet « children » ainsi que la documentation associée à la méthode sélectionnée :

Faire un double-clic pour saisir la méthode sélectionnée.

Si le curseur alphanumérique désigne une méthode, on obtient des renseignements sur cette méthode :

Dans le cas où, on référence une méthode que nous avons programmée, on obtient le nom complet de la méthode « package.classe.méthode » :

Si la méthode est commentée par exemple :

/**
* rend lenomdunoeud.
* @returnlenomdunoeud
*/
public String getNom() {
returnnom;
}

le commentaire est visualisé :

II-B - Création d'un graphe

Un graphe est créé à partir du modèle précédemment défini.

On créé sous « src » un « package » « monGraphe » qui contient la classe « MonGraphe ». On édite la classe MonGraphe :

package monGraphe;

import modeleGraphe.Arc;
import modeleGraphe.Graphe;
import modeleGraphe.Noeud;

publicclass MonGraphe extends Graphe {

public MonGraphe(){
new Noeud("start", this);
new Noeud("n1", this);
new Noeud("n2", this);
new Noeud("end",this);
new Arc("start", "n1", this);
new Arc("start", "n2", this);
new Arc("n1", "end", this);
new Arc("n2", "end", this);
new Arc("end", "start", this);
}

}

Faire une sauvegarde. On obtient :

II-C - Test du graphe

On crée sous « src » le package « testMonGraphe » pour recevoir la classe « TestMonGraphe ». Lors de la création de la classe « TestMonGraphe » dans la fenêtre « New Java Class  - Java Class » cocher « public static void main(...) »

On crée une instance de la classe « MonGraphe ».

On édite la classe :

package testMonGraphe;

import monGraphe.MonGraphe;

publicclass TestMonGraphe {

/**
* @param args
*/
publicstaticvoid main(String[] args) {
MonGraphe monGraphe = new MonGraphe();
System.out.println (monGraphe.toString());
}

}

Faire une sauvegarde. On obtient :

III - Test du code

Faire :

Dans « Run Configuration Create, manage, and run configurations », double-cliquer « Java Application », nommer la configuration. Cliquer « Apply ». On obtient :

Cliquer « Run » dans « Run configuration - Create, manage, and run configurations ».

La vue « Console » apparaît et affiche le graphe :

IV - Conclusions

À travers cette simple application, nous avons vu quelques rudiments de l'usage de l'« IDE Eclipse » qui nous seront nécessaires dans les exemples que nous allons développer.

Il existe bien d'autres fonctionnalités ! Le lecteur peut se reporter au « Help » :

(Commande: « Help > Help Contents »)

Globalement l'IDE étant intuitif, la pratique vous permettra de progresser rapidement.

Le modèle créé (Graphe, Nœud, Arc) est une solution que nous proposons, sa qualité dépend de notre maîtrise de la programmation objet !

V - Licence

La licence « Creative Commons » s'applique à ce document, veuillez-vous référer à ce site pour de plus amples informations : http://creativecommons.org/licenses/by-nc-nd/2.0/fr/.