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