Objectifs de ce cours (I21)

Présentation au sujet: "Objectifs de ce cours (I21)"— Transcription de la présentation:

1 Objectifs de ce cours (I21)
Classes et objets simples Découpage structurel et fonctionnel Modularité fonctionnelle, robustesse et maintenance Classes et objets simples sans méthode Méthodes d’instance simples Plus à propos de Java Classes et Objets ensemblistes Classes encapsulant des tableaux d’objets Résumé du cours précédent Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

2 Classes des cours et TD revisitées :
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 Classes des cours et TD revisitées : classe DonneJoueur // Variable d’instance -laDonne:Domino[] // Méthodes d’instance +donneToString():String +add(Domino d):void +add(Domino[] setDominos):void +isEmpty():boolean +size():int +extractDomino(int rg):Domino +extractDomino(Domino d):Domino +joueUnDomino(Pioche pioche, LigneDeJeu ldj):boolean +getDominoMaxValueToPlay(LigneDeJeu ldj):Domino // Cons. de donne vide +DonneJoueur() classe JeuDominos // Variable d’instance -jeu:Domino[] // Méthodes d’instance +createJeuNormal():void +jeuDominosToString():String +size():int // Cons. d’un jeu vide +JeuDominos() - = private + = public $ = static classe Pioche // Variable d’instance -laPioche:Domino[] // Méthodes d’instance +piocheToString():String +add(Domino d):void +add(Domino[] setDominos):void +isEmpty():boolean +size():int +piocheUnDomino():Domino // Cons. de pioche vide +Pioche() // Variable d’instance -ldj:Domino[] // Méthodes d’instance +ligneDeJeuToString():String +addToRight(Domino d):boolean +addToLeft(Domino d):boolean ... // Cons. de ligne vide +LigneDeJeu() classe LigneDeJeu Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

3 (A) CLASSE ENCAPSULANT UN TABLEAU D’OBJETS
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (A) CLASSE ENCAPSULANT UN TABLEAU D’OBJETS Résumé Nous avons vu : ➽ comment concevoir des classes qui encapsulent des tableaux d’objets (i.e. définir quelles méthodes d’instance nous seront utiles voire indispensables pour être en mesure de manipuler leurs objets le plus simplement possible depuis extérieur) ➽ comment écrire ces classes (i.e. faire des choix d’implémentation ; par exemple, construction à vide en utilisant null) ➽ comment faire interagir les objets par une utilisation correcte de la délégation (i.e. doter les bons objets des bonnes méthodes en prenant soin de relayer les traitements à réaliser jusqu’aux objets qui savent le mieux les faire) ➽ comment assurer la protection de l’état interne des objets depuis l’extérieur (i.e. interdire la visibilité directe des variables d’instance des objets en les déclarant private) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

4 Objectifs de ce cours (I21)
Classes et objets simples Découpage structurel et fonctionnel Modularité fonctionnelle, robustesse et maintenance Classes et objets simples sans méthode Méthodes d’instance simples Plus à propos de Java Classes et Objets ensemblistes Classes encapsulant des tableaux d’objets Classes génériques à spécialiser Maintenant ! Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

5 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER Nous avons vu des classes qui encapsulent des tableaux d’objets mais, on constate : ➽ que ces classes sont complexes à écrire (i.e. principalement par rapport à la gestion dynamique des tableaux qui nécessite des ré-instanciations des tableaux et des recopies de leurs éléments) ➽ que plusieurs méthodes identiques doivent être réécrites pour chaque classe (par exemple, c’est le cas des méthodes d’ajout, de suppression ou insertion d’éléments) Ces problèmes revenant souvent dans les programmes, les langages de programmations fournissent des types ou des librairies standards permettant de manipuler dynami-quement des ensembles d’éléments sans avoir à s’occuper des aspects statiques. En Java, on dispose notamment de classes génériques prêtes à être spécialisées. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

6 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> La classe générique ArrayList<E> ArrayList<E> doit être spécialisée à l’aide d’un nom de classe d’objets (ATTENTION: ArrayList<int> est interdit car int est un type primitif non objet) ➽ Exemples de spécialisation de la classe générique : ArrayList<Domino> représente, dès lors, la classe des listes de dominos ArrayList<Livre> représente, dès lors, la classe des listes de livres ArrayList<Integer> représente, dès lors, la classe des listes d’entiers ➽ si on veut les instancier, on peut utiliser un constructeur par défaut : new ArrayList<Domino>( ) instancie une liste de dominos vide new ArrayList<Livre>( ) instancie une liste de livres vide new ArrayList<Integer>( ) instancie une liste d’entiers vide ➽ si on voulait les instancier tout en conservant leurs références, on pourrait faire : ArrayList<Domino> listeDominos = new ArrayList<Domino>( ) ArrayList<Livre> listeLivres = new ArrayList<Livre>( ) ArrayList<Integer> listeEntiers = new ArrayList<Integer>( ) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

7 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Une fois la classe générique spécialisée, on dispose d’une véritable classe qui : ➽ encapsule un ensemble d’objets : la classe ArrayList<E> encapsule un tableau d’objets et en gère les aspects dynamiques induits par l’ajout, l’insertion ou la suppression d’éléments ➽ dispose de nombreuses méthodes d’instance publiques : par rapport à l’ensemble size(), isEmpty() par rapport à la lecture dans l’ensemble get(...), contains(...) par rapport à l’écriture dans l’ensemble add(...), clear(), remove(...), set(...) ➽ considère un ordre naturel sur l’ensemble : celui défini par les indices des éléments du tableau encapsulé De plus, les méthodes ont été implémentées pour s’exécuter en un temps optimal : ➽ optimisation en temps constant (soit O(1)) : obtention de la taille, test si vide, obtention d’un élément, remplacement d’un élément ➽ optimisation en temps linéaire (soit O(n)) mais en temps constant amorti (soit O(1)) : ajout, insertion, suppression ( Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

8 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Comment la classe ArrayList<E> gère-t-elle son tableau d’objet ? ➽ elle prévoit à l’avance une possible augmentation du nombre d’éléments : - elle gère le nombre d’éléments valides ainsi qu’une réserve d’emplacements libres - lorsque la réserve est vide, elle la reconstruit - finalement, elle maintient un tableau qui n’est que rarement complètement rempli o1 o2 o3 o4 o5 o6 o1 o2 o3 o4 o5 o6 o7 o8 o9 o10 ajouts de 4 éléments Éléments déjà présents Réserve Nouveaux éléments présents Taille réelle du tableau (plein) Taille réelle du tableau Si la taille de la réserve est du DOUBLE de celle du tableau (n éléments), vis-à-vis de l’OPERATION d’AJOUT : on a une complexité (au pire des cas) en temps linéaire, soit O(n) on a une complexité (moyenne) en temps constant amorti, soit O(1) car ((n-1)*O(1)+O(n))/n => O(1) ArrayList<E> ne double pas la taille du tableau MAIS utilise une taille variable de la réserve f(n) => la complexité moyenne est (f(n)-1)*O(1)+O(n))/f(n) soit en O(n/f(n)), ce qui revient à O(1) si f(n) est une fonction linéaire L’ancien tableau est détruit après avoir été reconstruit et recopié ajout d’un nouvel élément o1 o2 o3 o4 o5 o6 o7 o8 o9 o10 o1 o2 o3 o4 o5 o6 o7 o8 o9 o10 o11 Nouveaux éléments présents Nouvelle réserve Nouvelle taille réelle du tableau Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

9 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Méthodes utiles à connaître de la classe ArrayList<E> : ➽ par rapport à l’ensemble : int size() retourne la taille de l’ensemble boolean isEmpty() teste si l’ensemble est vide Object clone() retourne une copie de l’objet ArrayList<E> ...du tableau seulement (pas des éléments eux-mêmes) ➽ par rapport à la lecture dans l’ensemble : E get(int index) retourne l’élément d’indice index boolean contains(Object o) teste si l’ensemble contient l’objet o int indexOf(Object o) retourne l’indice de l’élément o ou -1 s’il n’existe pas int lastIndexOf(Object o) retourne l’indice du dernier élément o ou -1 s’il n’existe pas ➽ par rapport à l’écriture dans l’ensemble : boolean add(E e) ajoute un nouvel élément à la fin du tableau void add(int index, E e) insert un nouvel élément à l’indice index E set(int index, E e) remplace l’élément d’indice index par e et retourne l’ancien E remove(int index) supprime l’élément d’indice index et le retourne boolean remove(Object o) supprime l’élément o et retourne true s’il existait, false sinon ...retourne toujours true Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

10 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Comment utiliser la classe ArrayList<E> ? En O-O, il existe 3 manières différentes : ① directement dans la classe où on se trouve On instancie directement un objet ArrayList<Domino>. Puis on l’utilise à travers ses méthodes d’instance (celles des ArrayList<E>). ex: ArrayList<Domino> jeu = new ArrayList<Domino>(); jeu.add(new Domino(0,0)); ... Maintenant, il suffit d’appliquer les méthodes disponibles ② indirectement en l’encapsulant dans une nouvelle classe On crée, par exemple, une classe JeuDominos qui encapsule un private ArrayList<Domino>. Mais alors, on ne peut pas accéder aux méthodes d’instance précédentes directement de l’extérieur d’un objet JeuDominos. ex: JeuDominos jeu = new JeuDominos(); jeu.add(new Domino(0,0)); // erreur : la méthode add(...) n’existe pas On doit donc munir la classe JeuDominos de méthodes similaires Nous en verrons par la suite ③ en créant une nouvelle classe qui hérite des propriétés de l’objet ArrayList<E> Nous ne verrons cette méthode que plus tard Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

11 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Quel est le meilleur emplacement pour faire jouer les joueurs tour à tour ? On prévoira une méthode comme : public boolean jouerUnCoup() qui fera jouer un joueur à son tour en utilisant une variable qui indique toujours à quel joueur c’est le tour de jouer. Méthode ① (directe) Méthode ② (indirecte) Utilisation directe d’un ArrayList<E> On envisage une nouvelle classe Joueurs classe JeuDominos // Var. instance privées -joueurs:ArrayList<Joueur> -joueurQuiDoitJouer:int classe JeuDominos // Var. instance privées -joueurs:Joueurs ➽ Le meilleur emplacement est celui où l’on décide de placer l'ensemble des joueurs ① ② Encapsulation de l’ArrayList<E> dans la nouvelle classe Joueurs classe Joueurs // Var. instance privées -joueurs:ArrayList<Joueur> -joueurQuiDoitJouer:int ① Plus proche de l’utilisation de simples tableaux mais acceptable ici ! Plus proche du paradigme O-O (ce sont les joueurs qui savent qui doit jouer et quand) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

12 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Quelles sont les conséquences qui découlent du choix de méthode ? Méthode ① (directe) Méthode ② (indirecte) On doit placer la méthode dans la classe JeuDominos classe JeuDominos // Var. instance privées -joueurs:ArrayList<Joueur> -joueurQuiDoitJouer:int classe JeuDominos // Var. instance privées -joueurs:Joueurs On doit placer la méthode dans la classe Joueurs... ➽ La délégation a pour effet de réduire le problème global en le morcelant en plusieurs endroits (chaque partie du pb. devient plus claire car placé à l’endroit le plus judicieux) ① ② // Méthode d’instance +jouerUnCoup():boolean // Méthode d’instance +jouerUnCoup():boolean ...mais, en plus, on devra prévoir qu’elle puisse être invoquée depuis la classe JeuDominos (seule visible de l’extérieur) classe Joueurs // Var. instance privées -joueurs:ArrayList<Joueur> -joueurQuiDoitJouer:int Ici, c’est la classe JeuDominos qui doit supporter l’algorithmique qui permet de faire jouer le bon joueur au bon moment ① // Méthode d’instance +jouerUnCoup():boolean Ici, la classe JeuDominos délègue à la classe Joueurs la connaissance et l’algorithmique qui permet de faire jouer le bon joueur au bon moment Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

13 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Quel est le meilleur emplacement pour faire piocher un domino ? On prévoira la méthode : public Domino piocher() qui retournera un domino non nul pioché aléatoirement quand la pioche n’est pas vide et nul sinon. Méthode ① (directe) Méthode ② (indirecte) Utilisation directe d’un ArrayList<E> On envisage une nouvelle classe Pioche classe JeuDominos // Var. instance privées -pioche:ArrayList<Domino> classe JeuDominos // Var. instance privées -pioche:Pioche ① ② Encapsulation de l’ArrayList<E> dans la nouvelle classe Pioche classe Pioche // Var. instance privées -pioche:ArrayList<Domino> Déconseillé ici car le fait de piocher aléatoirement devient extérieur à l’objet pioche ! ➽ Le meilleur emplacement est toujours celui qui permet de garantir que des fonctionnalités importantes soient prises en charge par une classe spécifique (=> délégation) ① Plus proche du paradigme O-O (seule la pioche maîtrise la manière de piocher) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

14 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> Quel est le meilleur choix pour implémenter une ligne de jeu ? La gestion d’une ligne de jeu nécessite de nombreuses méthodes car il faut, par exemple : contrôler que les ajouts de dominos ne puissent être effectués qu’en début ou fin de jeu contrôler que les dominos joués soient vraiment accolables à une extrémité de ligne de jeu permettre de tester si des dominos donnés peuvent être joués ou non La méthode ① (directe) n’est évidemment pas adaptée ici car elle ne permet pas de réaliser un objet qui prenne en charge toutes les fonctionnalités importantes que devrait posséder une ligne de jeu. Méthode ② (indirecte) classe JeuDominos // Var. instance privées -ldj:LigneDeJeu On envisage une nouvelle classe LigneDeJeu ② Encapsulation de l’ArrayList<E> dans la nouvelle classe LigneDeJeu classe LigneDeJeu // Var. instance privées -ldj:ArrayList<Domino> ➽ Le meilleur emplacement est toujours celui qui permet de garantir que des fonctionnalités importantes soient prises en charge par une classe spécifique (=> délégation) ① Plus proche du paradigme O-O (la ligne de jeu garantie que le jeu est correct) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

15 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 (B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E> ➽ Résumé d’un choix possible entre les 2 méthodes d’utilisation des classes ensemblistes Encapsulation directe classe JeuDominos // Var. instance privées -joueurs:ArrayList<Joueur> -joueurQuiDoitJouer:int -jeuEnCours:boolean -pioche:Pioche -ldj:LigneDeJeu classe Joueur // Var. instance privées -donne:ArrayList<Domino> -nom:String -score:int ① ① Encapsulation dans une classe ad hoc ① ② ② classe Pioche // Var. instance privées -pioche:ArrayList<Domino> ② L’écriture de quelques méthodes est présentée en cours ➽ Ici, on n’a pas jugé utile de créer une classe Joueurs c’est donc le jeu de dominos lui-même qui devra gérer les joueurs et leurs tour de jouer (on a ajouter 2 variables pour cela) ① Ici, on a implicitement dans l’idée qu’un objet jeu de dominos fasse jouer un joueur en lui fournissant une pioche et une ligne de jeu. Si ces 2 derniers objets n’existaient pas (au travers de classes dédiées), il serait difficile de demander à un joueur de jouer car comment pourrait-il piocher ou poser son domino sur la ligne de jeu ? classe LigneDeJeu // Var. instance privées -ldj:ArrayList<Domino> ① ➽ De plus, on a implicitement dans l’idée qu’un objet JeuDominos fasse jouer un joueur en lui fournissant la pioche et la ligne de jeu... ...si ces 2 derniers objets n’existaient pas (au travers de classes dédiées), il serait difficile de demander à un joueur de jouer car comment pourrait-il piocher ou poser son domino sur la ligne de jeu ? Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

16 ArrayList<E> (exemple de code)
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 ArrayList<E> (exemple de code) classe JeuDominos // l’ensemble des joueurs et variables de conditions de jeu -joueurs:ArrayList<Joueur> -joueurQuiDoitJouer:int -pioche:Pioche // la pioche -jeuEnCours:boolean -ldj:LigneDeJeu // la ligne de jeu // Méthode permettant de faire jouer un coup au bon joueur public boolean jouerUnCoup() { } Algorithme général : ① faire attention aux conditions de jeu (jeuEnCours) ② déléguer le fait de jouer aux joueurs (joueur.jouerUnCoup(...) boolean hasPlayed = false; // le coup est supposé non joué // ne pas essayer de jouer si le jeu n’a pas commencé ou est terminé if ( this.jeuEnCours ) { } return hasPlayed; // renvoyer un indicateur de coup joué ① // faire jouer le joueur qui doit jouer... hasPlayed = // ...et récupérer ce qui s’est passé this.joueurs.get(this.joueurQuiDoitJouer) .jouerUnCoup(this.pioche, this.ligneDeJeu); ③ actualiser les nou-velles conditions de jeu (joueurQuiDoitJouer et jeuEnCours) ② // actualiser l’indice du prochain joueur qui doit jouer... if ( hasPlayed ) { // ...seulement si le joueur a joué this.joueurQuiDoitJouer = (this.joueurQuiDoitJouer+1 == this.joueurs.size() ? 0 : this.joueurQuiDoitJouer+1; } ③ On a utilisé 2 méthodes d’objet ensembliste ③’ // actualiser une éventuelle fin de jeu actualiserFinDeJeu(); // méthode qui mettra à jour this.jeuEnCours Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

17 ArrayList<E> (exemple de code)
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 ArrayList<E> (exemple de code) classe Joueur // ensemble des dominos du joueur -nom:String // le nom du joueur -donne:ArrayList<Domino> -score:int // le score du joueur // Méthode faisant jouer un coup à ce joueur public boolean jouerUnCoup(Pioche pioche, LigneDeJeu ldj) { } Algorithme général : ① faire attention aux conditions de jeu (pioche ou ligne de jeu incorrecte, donne initiale vide) boolean hasPlayed = false; // le coup est supposé non joué // ne pas essayer de jouer quand c’est impossible if ( ldj!=null && pioche!=null && !this.donne.isEmpty() ) { } return hasPlayed; // renvoyer un indicateur de coup joué ② essayer de jouer en boucle selon une certaine stratégie ① // essayer de jouer les dominos les uns après les autres... int i = -1; while ( ++i < this.donne.size() ) { } ② ②’ ...en testant des dominos sur la ligne de jeu (ldj.isAccolable(d)) //...en testant si le domino peut être joué sur la ligne de jeu if ( ldj.isAccolable( this.donne.get(i) ) ) { ... } ②’ ②" ...en piochant si nécessaire (pioche.piocher()) //...en piochant si nécessaire (si dernier domino non jouable) else if ( (i+1)==this.donne.size() && !pioche.isEmpty() ) { this.donne.add( pioche.piocher() ); } ②" On a utilisé 8 méthodes d’objet ensembliste (dont 3 qui restent encore à écrire) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

18 ArrayList<E> (exemple de code)
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 ArrayList<E> (exemple de code) classe Pioche // ensemble des dominos de la pioche -pioche:ArrayList<Domino> ① fournir une méthode permettant de savoir s’il reste des dominos dans la pioche // Méthode indiquant si la pioche est vide public boolean isEmpty() { // utiliser la méthode de l’objet ensembliste encapsulé return this.pioche.isEmpty(); } ① ② fournir une méthode permettant de piocher un domino : ② // Méthode permettant de piocher un domino public Domino piocher() { } Algorithme général : ②’ retourner null si la pioche est vide ②’ Domino dominoPioché = null; // aucun domino pioché par défaut // ne pas essayer de piocher si la pioche est vide if ( !isEmpty() ) { } return dominoPioché; // renvoyer le domino pioché (ou null) ②" piocher un domino aléatoirement (Math.random()) AUTRE METHODE POUR OBTENIR UN ENTIER ALEATOIRE: new Double(Math.random()*this.pioche.size()).intValue() ②" // former un indice aléatoire dans [0,taille de la pioche-1] int i = (int)(Math.random()*this.pioche.size()); // extraire le domino de la pioche avant de le retourner dominoPioché = this.pioche.remove(i); On a utilisé 4 méthodes d’objet ensembliste Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde La méthode de classe Math.random() renvoie une valeur double semi-aléatoire dans [0.0 , 1.0[

19 ArrayList<E> (exemple de code)
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 26/03/2017 ArrayList<E> (exemple de code) classe LigneDeJeu // ensemble des dominos de la ligne de jeu -ldj:ArrayList<Domino> ① fournir une méthode permettant de savoir s’il y a déjà un domino dans la ligne de jeu // Méthode indiquant si la ligne de jeu est vide public boolean isEmpty() { // utiliser la méthode de l’objet ensembliste encapsulé return this.ldj.isEmpty(); } ① ② fournir une méthode permettant de savoir si un domino peut être joué : ② // Méthode permettant de savoir si un domino fourni est accolable public boolean isAccolable(Domino d) { } Algorithme général : ②’ boolean accolableOK = (d != null); // vrai si la ligne de jeu est vide et que le domino fourni est valide, faux sinon if ( d!=null && !isEmpty() ) { } // renvoyer la valeur booléenne return accolableOK; ②’ retourner true si la ligne de jeu est vide et que le domino est valide AUTRE METHODE POUR isAccolable(d) : return ( isEmpty() ? true // toujours accolable si la ligne de jeu est vide : // sinon, il doit être accolable à droite ou à gauche accolableADroite(d) || accolableAGauche(d)); ②" // ici, il faut tester si le domino // est accolable à droite ou à gauche accolableOK = accolableADroite(d) || accolableAGauche(d); ②" sinon, indiquer s’il est accolable à droite ou à gauche On a utilisé 2 méthodes d’objet ensembliste Ces deux méthodes restent à écrire ainsi que de nombreuses autres dans cette classe comme cela a été présenté dans le cas d’encapsulation de tableaux d’objets Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

20 Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde
26/03/2017 Acta est fabula Acta est fabula : « La pièce est jouée. » On annonçait ainsi la fin de la représentation dans le théâtre antique. C’est tout pour aujourd’hui : version plus moderne ! Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde