1 Objectifs de ce cours (I21) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Résumé du cours précédent.

Présentation au sujet: "1 Objectifs de ce cours (I21) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Résumé du cours précédent."— Transcription de la présentation:

1

2 1 Objectifs de ce cours (I21) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Résumé du cours précédent

3 2 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde (B) CLASSES GÉNÉRIQUES À SPÉCIALISER : TreeMap La classe générique TreeMap TreeMap se spécialise à laide de 2 noms de classes dobjets : une classe qui représente les clés K et une autre des valeurs V Itération sur un dictionnaire Pour itérer sur les clés K, utiliser la méthode keySet () : Pour itérer sur les valeurs V, utiliser la méthode values () : TreeMap dicLivres = new TreeMap (); // ajout de livres dans le dictionnaire... dicLivres.put(unIsbn,unLivre)... // Itération sur les clés du dictionnaire for ( ISBN isbn : dicLivres. keySet ()) { System.out.println(isbn.isbnToString()); } TreeMap dicLivres = new TreeMap (); // ajout de livres dans le dictionnaire... dicLivres.put(unIsbn,unLivre)... // Itération sur les valeurs du dictionnaire for ( Livre livre : dicLivres. values ()) { System.out.println(livre.livreToString()); }

4 3 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER : TreeMap Ordonnancement de dictionnaires à laide de linterface Comparable Maintenant, on peut créer un dictionnaire de livres basé sur des clés ISBN. Exemple :TreeMap dicLivres = new TreeMap (); Implémentation simpliste à revoir ! Sinon, la plupart des classes du JDK implémentent déjà linterface Comparable. On peut donc les utiliser directement comme des clés pour des dictionnaires. Exemples :TreeMap dicJoueurs = new TreeMap (); TreeMap dicLivres = new TreeMap (); Déclaration dimplémentation de linterface Comparable Méthode de linterface devant être implémentée (à ajouter à la classe) Méthode de linterface devant être implémentée (à ajouter à la classe)

5 4 Objectifs de ce cours (I21) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Maintenant !

6 5 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Premiers éléments de modélisation en POO Repérage des classes candidates élémentaires On part du problème posé (à la manière dun cahier des charges) et exposé dans son domaine spécifique (sciences exactes, sciences expérimentales ou sciences humaines). On repère les entités élémentaires qui doivent être manipulées. Ce seront les premières classes candidates (ex: Domino, Livre, ISBN, Place). Repérage des classes candidates complémentaires de type ensembliste En général, les traitements devront manipuler des ensembles de données. On peut alors envisager plusieurs autres classes candidates de type ensembliste (ex: Pioche, LigneDeJeu, Donne, Bibliotheque, Graphe, Chemin). Repérage des classes candidates englobantes Il faudra généralement prévoir au moins une classe principale qui englobe/regroupe les entités du problème et à partir de laquelle les traitements sont initiés (ex: JeuDominos, Bibliotheque, Graphe) Repérage des classes candidates résultantes Parfois, il est également utile de prévoir une ou plusieurs classes qui engloberont les données résultantes fabriquées (ex: GrapheChemins)

7 6 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des données propres à chaque classe Une fois que lon dispose des grandes classes permettant de modéliser le problème, il faut affiner la modélisation en descendant au niveau interne des classes. On commence à préciser les variables dinstances et éventuellement de classe. En parallèle, il faut aussi prévoir : - leurs niveaux extérieur de visibilité (spécificateurs daccès public ou private) - et leur caractère mutable ou non (final). classe Domino private int m1, m2; Cette déclaration ne permet de modification des marques quà partir de méthodes dinstance Mais elle ne permet pas à lutilisateur daccéder aux marques depuis lextérieur. classe Domino public final int m1, m2; Cette déclaration fige les marques du domino après construction Et elle permet à lutilisateur dy accéder directement depuis lextérieur classe Domino public int m1, m2; // cette déclaration est dangereuse ! Cette déclaration permet à lutilisateur de modifier les marques du dominos comme bon lui semble depuis lextérieur de lobjet. Plus rien ne lui interdit de donner un état incohérent au domino. Par exemple : le domino (-54, 64831) !

8 7 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des données propres à chaque classe Règle à observer : dans un souci de plus grande autonomie des objets, il faut toujours protéger le plus possible les variables dinstance et de classe Si la variable ne doit plus changer de valeur après la construction : Une variable est dite sensible pour un objet quand létat global de lobjet peut être rendu incohérent si la valeur de la variable était changée arbitrairement depuis lextérieur Au final, il convient de bien choisir la déclaration des variables en fonction de ce que lon veut faire ! Si la variable doit pouvoir changer de valeur après la construction : si létat de la variable est sensible pour lobjet : toujours déclarer private si létat de la variable nest pas sensible pour lobjet : si on juge que létat de la variable peut intéresser lutilisateur de lobjet, déclarer public sinon, toujours déclarer private si on juge que létat de la variable peut intéresser lutilisateur de lobjet, déclarer public final sinon, toujours déclarer private final

9 8 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des données propres à chaque classe Alors, private ou public final ? Si, ayant fait une déclaration private, on désire quand même que lutilisateur accède à létat de la variable, on a toujours la possibilité de créer des « méthodes getters » ! accès à laide de GETTERS : accès DIRECT sans getter : public class Domino { private int m1, m2; public Domino( int m1, int m2) { this.m1 = m1; this.m2 = m2; } // Méthodes getters public int getM1() { return this.m1; } public int getM2() { return this.m2; }... public void retourne() { int m = this.m1; this.m1 = this.m2; this.m2 = m; } } // Par ailleurs (en dehors de la classe Domino) Domino d1 = new Domino(2,5); if (d1.m1 == 3 )... // accès direct INTERDIT ! d1.m1 = 3; // affectation INTERDITE ! if (d1.getM1() == 3 )...// accès par getter OK public class Domino { public final int m1, m2; public Domino( int m1, int m2) { this.m1 = m1; this.m2 = m2; }... } // Par ailleurs (en dehors de la classe Domino) Domino d1 = new Domino(2,5); if (d1.m1 == 3 )...// accès direct OK d1.m1 = 3;// affectation INTERDITE! if (d1.getM1() == 3 )... Seule cette version permettra de sécuriser le domino tout en pouvant le retourner (méthode qui échange les 2 marques) pour linsérer dans une ligne de jeu

10 9 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des données propres à chaque classe Attention aux constructeurs et getters/setters alliés aux déclarations private ! Lorsquun getter retourne un type primitif ou un objet immutable, il ny a pas de problème car la variable retournée est soit recopiée, soit constante. Mais lorsquun getter retourne une variable objet mutable, celle-ci pourra être modifiée en dehors. Et cela revient presque à donner un accès public à la variable ! GETTER retournant un objet mutable ! public class PointCouleur { private int x, y; private Couleur c; public PointCouleur( int x, int y, Couleur c){ this.x = x; this.y = y; this.c = c; } // Méthodes getters public int getX() { return this.x; } public int getY() { return this.y; } public Couleur getCouleur() { return this.c; }... } // Par ailleurs (en dehors des classes) Couleur c1 = new Couleur(255,0,0); PointCouleur p1 = new PointCouleur(2,5,c1); PointCouleur p2 = new PointCouleur(3,6,c1); public class Couleur { private int r, v, b; public Couleur( int r, int v, int b){ this.r = r; this.v = v; this.b = b; } // Méthodes getters public int getR() { return this.r; }... // Méthodes setters public void setR(int r) { this.r = r; }... } // la couleur du point peut être changée p1.getCouleur().setV(255); //...grâce au getter !!! c1.setB(255); //...et même sans le getter !!! Le PointCouleur ne sait pas que sa couleur (pourtant privée) a été changée ! Les PointCouleur p1 et p2 partagent la même couleur !

11 10 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des données propres à chaque classe Solution pour les déclarations private accompagnées de getters/setters Lorsquun getter retourne un objet mutable, il faudra toujours : - construire une copie de la variable objet fournie à la construction - utiliser une copie de la variable objet dans les getters et les setters GETTER et objet mutable correct public class PointCouleur { private int x, y; private Couleur c; public PointCouleur( int x, int y, Couleur c){ this.x = x; this.y = y; this.c = new Couleur(c.getR(),c.getV(),c.getB()); } // Méthodes getters public int getX() { return this.x; } public int getY() { return this.y; } public Couleur getCouleur() { return new Couleur(this.c.getR(), this.c.getV(), this.c.getB());}... // Méthodes setters public void setX(int x) { this.x = x; }... public void setCouleur(Couleur c) { this.c = new Couleur(this.c.getR(), this.c.getV(), this.c.getB());} } public class Couleur { private int r, v, b; public Couleur( int r, int v, int b){ this.r = r; this.v = v; this.b = b; } // Méthodes getters public int getR() { return this.r; }... // Méthodes setters public void setR(int r) { this.r = r; }... } Classe inchangée car nexposant que des types primitifs Classe qui expose un type objet (sa couleur) à protéger à la construction et des getters/setters

12 11 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des données propres à chaque classe Fort heureusement, la classe String est IMMUTABLE ! Étant immutables (une fois un objet String construit, il ne peut être modifié), les String peuvent être librement utilisés dans les getters/setters et dans les constructeurs sans que cela ne pose de problème. GETTER retournant un objet immutable public class Joueur { private String nom; public Joueur( String nom){ this.nom = nom; } // Méthode getter public String getNom(){return this.nom;}... } accès DIRECT à un objet immutable final public class Joueur { public final String nom; public Joueur( String nom){ this.nom = nom; }... } Ici, une fois quun joueur a été construit avec un nom, il ne peut plus en changer. Les deux déclarations produisent les mêmes comportements. Ici, une fois quun joueur a été construit avec un nom, il ne peut plus en changer. Les deux déclarations produisent les mêmes comportements. Par contre, la classe StringBuffer est MUTABLE ! En Java, la classe StringBuffer permet de construire des chaînes de caractères petit à petit dans un même objet. On dispose de nombreuses méthodes qui retournent souvent lobjet initial de sorte à pouvoir les enchaîner : - public StringBuffer append( ) - public StringBuffer insert( int index, ) - public StringBuffer delete( int indexStart, int indexEnd) - public char charAt(int index) - int indexOf(String str) où est char, boolean, int, double,..., String, StringBuffer http://java.sun.com/javase/6/docs/api/java/lang/String.html http://java.sun.com/javase/6/docs/api/java/lang/StringBuffer.html

13 12 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des comportements des objets On continue la modélisation en laffinant au niveau interne par la définition des comportements. Les comportements des objets représentent la partie à laquelle il faut apporter le plus de soin. Une classe qui ne fournirait pas les comportements attendus serait non seulement incorrecte mais, en plus, elle rendrait toutes les autres incorrectes vis-à-vis du paradigme Orienté Objets. Cela parce que, pour palier à linsuffisance de la classe, il serait nécessaire de prévoir des comportements dans dautres classes où il ne serait pas normal quils sy trouvent. Et, au bout du compte, il faudra reprendre non pas UNE mais PLUSIEURS classes ! Mais quels sont les comportements attendus pour une classe donnée ? Cest exactement la question quil faut se poser pour chaque classe ! En POO, lensemble des objets sont en interactions mais chacun réalise une partie spécifique du problème global. À partir de là, il faut et il suffit que chaque classe offre toutes les méthodes utiles pour permettre de lui faire faire ce quelle doit faire. En même temps, une classe peut elle-même en utiliser dautres pour laider à réaliser sa partie mais il sagit ici de délégation. Une classe doit déléguer à dautres ce quelles savent mieux faire. La délégation est donc justement ce qui réalise les interactions entre classes. Mais la délégation a à voir avec lalgorithmique, pas avec la recherche des méthodes utiles à une classe donnée.

14 13 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Modélisation des comportements des objets La modélisation des comportements consiste à mettre de lordre dans : « qui doit faire quoi ? » ou « qui doit proposer quoi ? » Par exemple, un jeu de cartes (classe JeuCartes) doit permettre de construire des jeux de 32, 34, 52 ou 54 cartes. Il faut donc prévoir des constructeurs en conséquence. Par ailleurs, il faudra aussi construire chaque carte (classe Carte) mais le jeu de cartes ne proposera pas dajouter de nouvelles cartes. Il pourra fonctionner comme un talon qui fournit la carte du dessus ou reçoit une carte en dessous, etc. Ensuite, pour faire des réussites – par exemple la réussite Joséphine ou la réussite Horloge – il faudra disposer de classes spécifiques (classes ReussiteJoséphine et ReussiteHorloge). Ces classes ne proposeront pas de construire le jeu de cartes, il devra être automatiquement construit par la classe de la réussite choisie. Par contre, chaque classe de réussite devra au moins proposer des méthodes qui permettent de faire progresser la réussite dun pas, de simuler une réussite dun coup ou dafficher un état intermédiaire de la réussite, etc. Dautres classes seront utiles comme nous lavons vu, par exemple la classe PlateauCartes qui prendra en charge la disposition des cartes sur le plateau de jeu et qui fournira quelques compor- tements utiles comme de remplir le plateau avec un talon de cartes, de savoir si une carte donnée se trouve accessible sur le plateau, de retrouver la dernière carte dune colonne ou dune ligne, etc.

15 14 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Simplement à partir de là, nous allons construire un modèle OO qui permette de répondre à ce type de problématique. Pour modéliser le problème, nous devons commencer par définir les entités les plus évidentes. Si nous voulons aller dun point à un autre, il faudra nécessairement définir des emplacements que nous pourrons éventuellement nommer. appelons-les des places et envisageons une classe Place Ensuite, interrogeons-nous sur ce que sera un lien dune place à lautre. Sil doit exister des chemins plus courts que les autres, il faut nécessairement que dune place on puisse se rendre à plusieurs autres. Il faudra donc, pour chaque place, tenir une liste des places atteignables directement. De plus, léloignement entre deux places doit être quantifiable. Pour simplifier, décidons quil sagira dune donnée entière. appelons cette mesure la valuation dune place à une autre et envisageons un type primitif int voire une classe IntegerTiens ! Ce nest pas une nouvelle classe ! Maintenant que nous avons des places liées les unes aux autres, nous devons envisager de disposer dun ensemble de places. Ensemble à lintérieur duquel nous chercherons des chemins. Si nous représentons un tel ensemble, nous allons nous apercevoir quil a la forme dun graphe. appelons- le ainsi et envisageons une classe Graphe Nous allons nous intéresser à un problème de recherche de plus courts chemins pour aller dun point à un autre.

16 15 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Par exemple, le schéma suivant représente un graphe : o de 6 places nommées de "A" à "F » o avec 8 liaisons o et où chaque place a de 2 à 4 liaisons Maintenant, voyons un graphe simple (graphe où les places ont au maximum 2 liens) : Dans ce cas, la recherche du plus court chemin est très simplifiée ! Ce dernier graphe peut nous permettre de revoir la représentation du précédent en choisissant des chemins linéaires et en les plaçant pareillement en ligne droite. Si le chemin contient toutes les places, il ne devrait rester quà ajouter quelques liens supplémentaires pour terminer sinon il faudra encore y ajouter les places manquantes. E E B B F F A A C C D D E E B B F F A A C C D D E E B B F F C C D D A A D D B B E E F F C C A A TOUS LES GRAPHES BLEUS SONT IDENTIQUES LA FORME DONNÉE À UN GRAPHE NEST QUE PEU SIGNIFICATIVE À ce point, faisons une petite digression pour mieux nous représenter ce quest un graphe.

17 16 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Si nous voulons trouver des chemins, il faudra aussi prévoir comment représenter ces chemins. Par définition, un chemin ne sera quune liste ordonnée de places aussi nous avons le choix entre : 1.soit utiliser directement un ArrayList en tant que variable dinstance là où cest utile, (ce choix convient lorsquil ny a quun endroit où utiliser des chemins et quil ny a que très peu de méthodes spécifiques les concernant, généralement de simples itérations sur leurs éléments) 2.soit définir une classe spécifique – la classe Chemin – qui, encapsulant un ArrayList, permettra de fournir des méthodes utiles à la manipulation de chemins. (ce choix conviendra lorsquil y aura au moins une méthode importante à implémenter ou quil faille utiliser des chemins à plusieurs endroits du programme) Nous choisirons la seconde méthode en pensant au fait quil sera utile de déterminer la valuation totale dun chemin et que cela nest pas si trivial quon puisse ne pas le proposer. envisageons une classe Chemin Maintenant, sachant quil ny aura pas toujours un unique chemin plus court que les autres mais quil pourra y en avoir plusieurs, il faut se poser la question de lutilité dune classe ensembliste de chemins (le problème est le même que précédemment avec ses 2 choix possibles, soir directement un ArrayList, soit une classe Chemins qui encapsule un ArrayList ). Or, si plusieurs chemins sont envisageables, il faudra bien quelques méthodes pour nous aider à trouver celui que nous préférons. envisageons une classe Chemins Poursuivons notre modélisation

18 17 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Dévidence, la classe Graphe sera la classe englobante de notre applicatif puisque nous naurons quà construire un graphe et à en obtenir des chemins. soit la classe englobante Graphe Mais puisquil nous sera éventuellement fourni plusieurs chemins, il serait bon de disposer dune classe résultante qui contiendra tout ce quil faut pour filtrer les chemins et choisir celui qui nous conviendra le mieux. Nous avons déjà prévu une telle classe, la classe Chemins. Comme il sagit maintenant dune classe résultante, nous en profiterons pour y insérer un peu plus dinformations quune simple liste de chemins. Par exemple, nous pourrons référer au graphe et aux places de départ et darrivée des chemins. Rebaptisons-là sous le nom de GrapheChemins. soit la classe résultante GrapheChemins Poursuivons notre modélisation : quen sera-t-il des classes englobantes et résultantes ? Ce devrait être tout pour cette étape de recherche des entités de modélisation du problème !

19 18 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Finalement, voici nos classes : une classe Place qui représente un emplacement et possède des liens valués vers dautres places une classe Graphe qui connaît toutes les places une classe Chemin qui contient les places de départ, intermédiaires et darrivée une classe GrapheChemins qui contient une liste de chemins relative à un graphe et à un trajet voulu Il convient daffiner la modélisation en descendant au niveau interne des classes à commencer par définir les données propres à chaque classe puis en définissant leurs comportements Finalement, voici nos classes : Poursuivons notre modélisation

20 19 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO La classe Place représente un emplacement et possède des liens valués vers dautres places Chaque place sera représenté par un nom. De plus, une place naura pas à changer de nom mais celui-ci devra être accessible. soit la variable dinstance public final String nom La classe Place Pour les liens vers les autres places, un ArrayList serait suffisant mais il faut aussi définir les valuations entre places. Or, chaque liaison doit être valuée à laide dune donnée entière (égale à lunité par défaut) quil faudra pouvoir retrouver sur la base dune place. On peut donc penser à un dictionnaire dont les clés seraient les places. Soit un dictionnaire de valuations rangées par les places, i.e. un TreeMap (puisquil nest pas possible dutiliser un type primitif int). soit la variable dinstance private TreeMap mapValuations La place B qui est liée à 4 places E F C A B B // *********************************************************************** // Variables d'instance // *********************************************************************** /** Nom de la place (doit être unique dans un graphe). */ public final String nom; /** * Dictionnaire des valuations des places liées * (par défaut, les valuations sont égales à l'unité). */ private TreeMap mapValuations;

21 20 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO La classe Graphe connaît toutes les places Un graphe doit simplement posséder une liste de places (par ailleurs toutes liées entre elles). Un simple ArrayList suffirait a priori mais, si lon pense à la construction du graphe, comme il faudra ajouter les places une à une, il peut être intéressant de prévoir une liste qui permette de savoir facilement si une place de même nom nexiste pas déjà. On sorientera donc vers un dictionnaire de places rangées par leurs noms. soit la variable dinstance private TreeMap mapOfPlaces La classe Graphe Le graphe exemple qui possède un dictionnaire de 6 places Le graphe exemple qui possède un dictionnaire de 6 places,,,,, A A A A B B B B C C C C F F F F D D D D E E E E // *********************************************************************** // Variables d'instance // *********************************************************************** /** Dictionnaire des places du graphe accessibles selon leurs noms (String). */ private TreeMap mapOfPlaces;

22 21 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO La classe Chemin qui contient les places de départ, intermédiaires et darrivée Un chemin est simplement représenté par une liste ordonnée de places. Il devra au moins contenir deux places – de départ et darrivée – et éventuellement dautres places intermédiaires. De plus, chaque place devra être directement joignable depuis la précédente. Un simple ArrayList suffit donc. soit la variable dinstance private ArrayList allPlaces La classe Chemin // *********************************************************************** // Variables d'instance // *********************************************************************** /** Les places ordonnées de ce chemin ; considéré vide tant qu'il ne contient * aucun trajet (i.e. au moins deux places). */ private ArrayList allPlaces;

23 22 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO La classe GrapheChemins qui contient une liste de chemins relative à un graphe et à un trajet voulu Comme il sagit de lunique classe résultante de lapplicatif, nous y mettrons suffisamment dinformations pour la rendre autonome. Ainsi, une fois récupéré un tel objet, on disposera de toutes les informations utiles pour en interpréter les résultats. Elle contiendra : - une liste de chemins sous la forme dune ArrayList - la référence au graphe rattaché à cette liste de chemins - la place de départ - la place darrivée La classe GrapheChemins // *********************************************************************** // Variables d'instance // *********************************************************************** /** Le graphe rattaché à cette liste de chemins. */ public final Graphe graphe; /** La place de départ rattachée à cette liste de chemins. */ public final Place placeFrom; /** La place d'arrivée rattachée à cette liste de chemins. */ public final Place placeTo; /** La liste des chemins menant de la place de départ à la place d'arrivée. */ private ArrayList allChemins; Seule la liste de chemins, devant être construite au fur et à mesure, sera déclarée private. Les autres données seront public final.

24 23 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO À ce niveau, il ne sagit que de définir les méthodes principales car on ne peut pas encore savoir exactement toutes les méthodes qui savèreront utiles. Certaines napparaîtront quà limplémentation. Mais, dans un esprit généraliste, on proposera, plusieurs versions de certaines méthodes (surcharges) quand cela apparaîtra utile (même sil savèrera plus tard quelles ne seront pas toutes utilisées). Cette manière de faire permet de donner une plus grande souplesse dutilisation des classes (en effet, en prévoyant plusieurs manières de réaliser une même fonctionnalité, on donne à la fois une grande étendue et une forte spécificité aux classes). Il ne reste quà définir les comportements de chaque classe (une manière de faire est de partir de la classe englobante). Poursuivons notre modélisation

25 24 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Quand nous construirons un graphe, il faudra définir les places et leurs liens mais il ne sera pas toujours possible de définir immédiatement tous les liens car certaines places pourront ne pas encore exister. Pour faire simple, on proposera donc de construire dabord toutes les places puis, ensuite seulement, de définir les liens des places entre elles. La classe Graphe (classe englobante) Au départ, on voudra construire un graphe vide. public Graphe() Ensuite, on devra insérer des places les unes après les autres public boolean addPlace(String nomPlace) // place fournie par son nom public boolean addPlace(Place place) // place fournie directement Puis, on définira leurs liaisons et leurs valuations public boolean addLiaison(String place1, String place2) // valuation par défaut public boolean addLiaison(String place1, String place2, int valuation) On prévoira aussi des méthodes dinformations public boolean hasPlace(String nomPlace)// cet nom de place existe-t-il déjà ? public boolean hasPlace(Place place) // cette place existe-t-elle déjà ? public boolean isConsistant()// le graphe est-il consistant ?

26 25 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO La classe Graphe (suite) On prévoira des méthodes dinformations générales public int getNombrePlaces() // nombre de places total public int getNombreLiaisons() // nombre de liaisons total public double getValuationMoyenne()// la valuation moyenne totale On prévoira aussi une méthode de représentation textuelle du graphe public String toString() Enfin, il faudra bien sûr prévoir une méthode qui fournira tous les chemins dune place de départ à une place darrivée dans un objet résultant (on réservera le filtrage du plus court chemin dans lobjet résultant obtenu) public GrapheChemins getAllChemins(String placeDepart, String placeArrivee) Les méthodes fournies en plusieurs versions (surcharges) sont en général simples à écrire car il suffit de détailler la plus générale dentre elles, toutes les autres sy ramenant.

27 26 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO En premier lieu, puisque cette classe est utilisée comme clé dans son TreeMap, elle devra implémenter linterface Comparable public int compareTo(String nomPlace) On voudra construire une place par son nom. public Place(String nomPlace) // place construite par son nom Puis, on définira ses liaisons et ses valuations avec dautres places public boolean addLiaison(String place1, String place2) // valuation par défaut public boolean addLiaison(String place1, String place2, int valuation) On prévoira des méthodes dinformations public String getNom()// quel est le nom de cette place ? public boolean hasLiaison(Place placeLiee)// cette liaison existe-t-elle déjà ? public int getValuationWithPlace(Place placeLiee) // la valuation de la liaison On prévoira des méthodes dinformations générales public int getNombreLiaisons()// le nombre total de liaisons public Set getSetOfPlacesLiees()// la liste des places liées à celle-ci On prévoira aussi une méthode de représentation textuelle de la place public String toString() La classe Place

28 27 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO On voudra construire un chemin vide en spécifiant la place de départ. public Chemin(Place placeFrom) // chemin vide (pas encore de trajet) Puis, on voudra ajouter les places du chemin les unes après les autres (en queue de liste) public boolean add(Place place)// ajout dune place en queue de chemin On prévoira des méthodes dinformations public boolean contains(String nomPlace)// ce nom de place est-il déjà joint ? public boolean contains(Place place)// cette place est-elle déjà jointe ? public Place getLastPlace() // la dernière place du chemin On prévoira des méthodes dinformations générales public Place getNombrePlaces()// nombre total de places public Place getValuationTotale()// valuation totale du chemin public Place getPlaceFrom()// quelle est la place de départ ? public Place getPlaceTo()// quelle est la place darrivée ? public ArrayList getAllPlaces()// la liste des places de ce chemin On prévoira aussi une méthode de représentation textuelle de la place public String toString() La classe Chemin

29 28 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO On voudra construire une liste de chemins vide rattachée à un graphe et un trajet (départ/arrivée). public GrapheChemins(Graphe graphe, Place placeFrom, Place placeTo) Puis, on voudra ajouter des chemins complets (départ/arrivée) au fur et à mesure public boolean addCheminComplet(Chemin chemin)// ajouter un chemin complet On prévoira des méthodes dinformations générales public boolean isValide() // les données de base sont-elles valides ? public ArrayList getAllChemins()// donne tous les chemins public ArrayList getAllPlusCourtsChemins()// + les plus courts public ArrayList getAllPlusCourtsCheminsMinEtapes() // + minimum détapes On prévoira aussi une méthode de représentation textuelle de la liste des chemins public String toString() Enfin, on pourra prévoir une méthode qui construira tous les chemins de la place de départ à la place darrivée pour le graphe rattaché (cette méthode pourra être appelée par le graphe qui dispose dune méthode identique) public GrapheChemins constructAllChemins() La classe GrapheChemins (classe résultante)

30 29 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple de modélisation en POO Les noms des places ne doivent être ni nuls ni vides. Les places doivent avoir un nom unique dans les graphes. Les graphes doivent contenir des places toutes liées entre elles de sorte à pouvoir aller de nimporte quelle place à nimporte quelle autre. Les listes de places des chemins doivent être maintenues ordonnées et chaque place doit posséder une liaison directe vers la place suivante (sauf la dernière). Les listes de chemins ne doivent contenir que des chemins complets (i.e. qui vont de la place de départ à la place darrivée). Etc. Une fois la modélisation réalisée, il faut résumer les directives importantes en vu de limplémentation.

31 30 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Un exemple dimplémentation Enfin, il ne reste plus quà procéder à limplémentation. Cette étape est du ressort du programmeur. Son rôle est dassurer la cohérence interne des objets en prenant soin de traiter tous les cas qui peuvent se présenter (références nulles ou invalides dans les paramètres fournis...). public class Graphe { // Variables d'instance /** Dictionnaire des places du graphe accessibles selon leurs noms (String). */ private TreeMap mapOfPlaces; // Constructeur public Graphe() { // construction dun graphe vide this.mapOfPlaces = new TreeMap (); } // Méthodes d'instance public boolean addPlace(String nomPlace) { // ajout dune place fournie par son nom return addPlace(new Place(nomPlace)); } public boolean addPlace(Place place) { // ajout dune place fournie directement boolean ok = false; if ( place != null ) { String nom = place.getNom(); if ( !nom.isEmpty() && !this.mapOfPlaces.containsKey(nom) ) { this.mapOfPlaces.put(nom, place); ok = true; } return ok; } On utilise la méthode surchargée (plus générale) en délégant à la classe Place sa construction. On sassure que la place soit un objet valide On sassure quelle a un nom et quil nexiste pas encore dans le graphe Maintenant, on peut lajouter au graphe

32 31 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde Acta est fabula