objectifs de ce cours (i21)

1Objectifs de ce cours (I21)

Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

Résumé du cours précédentRésumé du cours précédent

2


classe JeuDominos// Variable d’instance-jeu:Domino[]

// Méthodes d’instance+createJeuNormal():void+jeuDominosToString():String+size():int

// Cons. d’un jeu vide+JeuDominos()

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()

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()

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

3


(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)

4Objectifs de ce cours (I21)


Maintenant !Maintenant !

5


(B) CLASSES GÉNÉRIQUES À SPÉCIALISER

Nous avons vu des classes qui encapsulent des tableaux d’objetsmais, on constate :

➽ que ces classes sont complexes à écrire(i.e. principalement par rapport à la gestion dynamique des tableaux qui nécessite desré-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.

6


(B) CLASSES GÉNÉRIQUES À SPÉCIALISER: ArrayList<E>

La classe générique ArrayList<E>

➽ Exemples de spécialisation de la classe générique :ArrayList<Domino> représente, dès lors, la classe des listes de dominosArrayList<Livre> représente, dès lors, la classe des listes de livresArrayList<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 videnew ArrayList<Livre>( ) instancie une liste de livres videnew 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>( )

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)

7



➽ 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(...)

➽ 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 (http://fr.wikipedia.org/wiki/Analyse_amortie)

Une fois la classe générique spécialisée, on dispose d’une véritable classe qui :

De plus, les méthodes ont été implémentées pour s’exécuter en un temps optimal :

➽ considère un ordre naturel sur l’ensemble :celui défini par les indices des éléments du tableau encapsulé

8



➽ 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

Comment la classe ArrayList<E> gère-t-elle son tableau d’objet ?

o1 o2 o3 o4 o5 o6 o1 o2 o3 o4 o5 o6 o7 o8 o9 o10

Éléments déjà présents Réserve

Taille réelle du tableau Taille réelle du tableau (plein)

Nouveaux éléments présents

o1 o2 o3 o4 o5 o6 o7 o8 o9 o10o11

ajout d’un

nouvel élément

Nouvelle taille réelle du tableau

Nouveaux éléments présents Nouvelle réserve

ajouts de 4

éléments

o1 o2 o3 o4 o5 o6 o7 o8 o9 o10

L’ancien tableau est détruit après avoir été reconstruit et recopié

9



➽ par rapport à l’ensemble :int size() retourne la taille de l’ensembleboolean isEmpty() teste si l’ensemble est videObject clone() retourne une copie de l’objet ArrayList<E>

Méthodes utiles à connaître de la classe ArrayList<E> :

➽ par rapport à l’écriture dans l’ensemble :boolean add(E e) ajoute un nouvel élément à la fin du tableauvoid add(int index, E e) insert un nouvel élément à l’indice indexE set(int index, E e) remplace l’élément d’indice index par e et retourne l’ancienE remove(int index) supprime l’élément d’indice index et le retourneboolean remove(Object o) supprime l’élément o et retourne true s’il existait, false sinon

➽ par rapport à la lecture dans l’ensemble :E get(int index) retourne l’élément d’indice indexboolean contains(Object o) teste si l’ensemble contient l’objet oint indexOf(Object o) retourne l’indice de l’élément o ou -1 s’il n’existe pasint lastIndexOf(Object o) retourne l’indice du dernier élément o ou -1 s’il n’existe pas

...du tableau seulement (pas des

éléments eux-mêmes)

...retourne toujours true

10



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)); ...

③ en créant une nouvelle classe qui hérite des propriétés de l’objet ArrayList<E>

Nous en verrons par la suiteNous en verrons par la suite

Maintenant, il suffit d’appliquer les méthodes

disponibles

Maintenant, il suffit d’appliquer les méthodes

disponibles

Nous ne verrons cette méthode que plus tard

Nous ne verrons cette méthode que plus tard

11



Quel est le meilleur emplacement pour faire jouer les joueurs tour à tour ?

classe JeuDominos// Var. instance privées-joueurs:ArrayList<Joueur>

-joueurQuiDoitJouer:int①

classe JeuDominos// Var. instance privées-joueurs:Joueurs

classe Joueurs// Var. instance privées-joueurs:ArrayList<Joueur>

-joueurQuiDoitJouer:int

②

Utilisation directe d’un

ArrayList<E>


ArrayList<E>

On envisage une nouvelle

classe Joueurs

On envisage une nouvelle

classe Joueurs

①

Méthode (directe)① Méthode (indirecte)②

Encapsulation de l’ArrayList<E> dans la nouvelle classe Joueurs

Encapsulation de l’ArrayList<E> dans la nouvelle classe Joueurs

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.

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.

Plus proche del’utilisation de

simples tableaux mais acceptable ici !

Plus proche duparadigme O-O

(ce sont les joueurs qui savent qui doit jouer et

quand)

➽ Le meilleur emplacement est celui où l’on décide de placer l'ensemble des joueurs

➽ Le meilleur emplacement est celui où l’on décide de placer l'ensemble des joueurs

12



Quelles sont les conséquences qui découlent du choix de méthode ?



classe JeuDominos// Var. instance privées-joueurs:Joueurs

classe Joueurs// Var. instance privées-joueurs:ArrayList<Joueur>



// Méthode d’instance+jouerUnCoup():boolean

On doit placer la

méthode dans la classe

JeuDominos

On doit placer la

méthode dans la classe

JeuDominos



②

Ici, c’est la classe JeuDominos qui doit supporter l’algorithmique qui permet de faire jouer le bon

joueur au bon moment

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

➽ 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 clairecar placé à l’endroit le plus judicieux)

➽ 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 clairecar placé à l’endroit le plus judicieux)

...mais, en plus, on devra

prévoir qu’elle puisse être

invoquée depuis la classe

JeuDominos (seule visible de

l’extérieur)

...mais, en plus, on devra

prévoir qu’elle puisse être

invoquée depuis la classe

JeuDominos (seule visible de

l’extérieur)

On doit placer la méthode

dans la classe Joueurs...

On doit placer la méthode

dans la classe Joueurs...

13



Quel est le meilleur emplacement pour faire piocher un domino ?

classe JeuDominos// Var. instance privées-pioche:ArrayList<Domino>

①

classe JeuDominos// Var. instance privées-pioche:Pioche

classe Pioche// Var. instance privées-pioche:ArrayList<Domino>

②


ArrayList<E>


ArrayList<E>

On envisage une nouvelle classe Pioche

On envisage une nouvelle classe Pioche

①


Encapsulation de l’ArrayList<E> dans la nouvelle

classe Pioche


classe Pioche

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.

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.

Déconseillé ici car le fait de piocher aléatoirement devient

extérieur à l’objet pioche !


(seule la pioche maîtrise la manière de piocher)

➽ 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)



14



Quel est le meilleur choix pour implémenter une ligne de jeu ?

classe JeuDominos// Var. instance privées-ldj:LigneDeJeu

classe LigneDeJeu// Var. instance privées-ldj:ArrayList<Domino>

②

On envisage une nouvelle classe

LigneDeJeu

On envisage une nouvelle classe

LigneDeJeu

①

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 LigneDeJeu


classe LigneDeJeu

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 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 ligne de jeu garantie que le jeu est correct)





15



➽ Résumé d’un choix possible entre les 2 méthodesd’utilisation des classes ensemblistes


-joueurQuiDoitJouer:int-jeuEnCours:boolean

-pioche:Pioche-ldj:LigneDeJeu

classe Joueur

// Var. instance privées-donne:ArrayList<Domino>-nom:String-score:int

classe Pioche// Var. instance privées-pioche:ArrayList<Domino>

classe LigneDeJeu

// Var. instance privées-ldj:ArrayList<Domino>

①

②

②①

①

①

L’écriture de quelques méthodes est présentée

en cours

①

②

Encapsulation directe

Encapsulation dans une classe ad hoc

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

➽ 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 ?

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

➽ 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 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)

16


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 joueurpublic boolean 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 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;}

① faire attention aux conditions de jeu(jeuEnCours)

② déléguer le fait de jouer aux joueurs(joueur.jouerUnCoup(...)

③ actualiser les nou-velles conditions de jeu(joueurQuiDoitJouer et jeuEnCours)

①

②

③

// actualiser une éventuelle fin de jeuactualiserFinDeJeu(); // méthode qui mettra à jour this.jeuEnCours

’③

Algorithme général :

On a utilisé 2 méthodes d’objet ensembliste

17


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 joueurpublic boolean jouerUnCoup(Pioche pioche, LigneDeJeu ldj) {

}

boolean hasPlayed = false; // le coup est supposé non joué// ne pas essayer de jouer quand c’est impossibleif ( ldj!=null && pioche!=null && !this.donne.isEmpty() ) {

}return hasPlayed; // renvoyer un indicateur de coup joué

// essayer de jouer les dominos les uns après les autres...int i = -1;while ( ++i < this.donne.size() ) {

}

//...en testant si le domino peut être joué sur la ligne de jeuif ( ldj.isAccolable( this.donne.get(i) ) ) {

...}

① faire attention aux conditions de jeu(pioche ou ligne de jeu incorrecte, donne initiale vide)

② essayer de jouer en boucle selon une certaine stratégie

’ ② ...en testant des dominos sur la ligne de jeu (ldj.isAccolable(d))

①

②

’②

//...en piochant si nécessaire (si dernier domino non jouable)else if ( (i+1)==this.donne.size() && !pioche.isEmpty() ) {

this.donne.add( pioche.piocher() );}

②"


②" ...en piochant si nécessaire(pioche.piocher())

On a utilisé 8 méthodes d’objet ensembliste(dont 3 qui restent

encore à écrire)

18


classe Pioche// ensemble des dominos de la pioche-pioche:ArrayList<Domino>

// Méthode indiquant si la pioche est videpublic boolean isEmpty() {

// utiliser la méthode de l’objet ensembliste encapsuléreturn this.pioche.isEmpty();

}

// Méthode permettant de piocher un dominopublic Domino piocher() {

}

Domino dominoPioché = null; // aucun domino pioché par défaut// ne pas essayer de piocher si la pioche est videif ( !isEmpty() ) {

}return dominoPioché; // renvoyer le domino pioché (ou null)

① fournir une méthode permettant de savoir s’il reste des dominos dans la pioche

② fournir une méthode permettant de piocher un domino :

’ ② retourner null si la pioche est vide

①

②

’②

// 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 retournerdominoPioché = this.pioche.remove(i);

②"


②" piocher un domino aléatoirement(Math.random())


La méthode de classe Math.random() renvoie une valeur double semi-aléatoire dans [0.0 , 1.0[

19


classe LigneDeJeu// ensemble des dominos de la ligne de jeu-ldj:ArrayList<Domino>

// Méthode indiquant si la ligne de jeu est videpublic boolean isEmpty() {

// utiliser la méthode de l’objet ensembliste encapsuléreturn this.ldj.isEmpty();

}

// Méthode permettant de savoir si un domino fourni est accolablepublic boolean isAccolable(Domino d) {

}

boolean accolableOK = (d != null); // vrai si la ligne de jeu est vide et que le domino fourni est valide, faux sinonif ( d!=null && !isEmpty() ) {

}// renvoyer la valeur booléennereturn accolableOK;

① fournir une méthode permettant de savoir s’il y a déjà un domino dans la ligne de jeu

② fournir une méthode permettant de savoir si un domino peut être joué :

’ ② retourner true si la ligne de jeu est vide et que le domino est valide

①

②

’②

// ici, il faut tester si le domino// est accolable à droite ou à gaucheaccolableOK = accolableADroite(d) || accolableAGauche(d);

②"


②" sinon, indiquer s’il est accolable à droite ou à gauche


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

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

20


Acta est fabula

objectifs de ce cours (i21)

Documents