1 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde COURS 3 : Programmation impérative Résumé du cours précédent

1

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

COURS 3 : Programmation impérative

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

2


classe MainDominos

+$ main(String[]) { test1(); }

+$ test1() {

Domino d4 = new Domino(3,4); if ( ) { // faire quelque chose... }}

classe Domino

m1 : intm2 : int

+Domino(int,int)+Domino(int)+Domino()

public boolean estDouble(){ }return ( == );this.m1 this.m2

① invocation de la méthode

② mise à jour de « this »

③ exécution de la méthode

Maintenant « this » réfère à d4

③ Et ce n’est qu’ensuite que Java exécute la méthode dans sa classe propre.

d4.estDouble()

3


Classes&objets: CONSTRUCTEURS, VARIABLES et METHODES D’INSTANCE

classe Dominom1 : intm2 : int


Classes & Objets = VARIABLES D’INSTANCES (=ATTRIBUTS)+ CONSTRUCTEURS + METHODES D’INSTANCES

+dominoToString(): String+estDouble(): boolean+valeur() : int+plusGrandQue(Domino d) : int+plusGrandeMarque() : int

CONSTRUCTEURS

METHODESD’INSTANCE

C’est de cette manière que les objets et leurs classes

doivent être conçus dans le paradigme Orienté-Objet.

VARIABLESD’INSTANCE

ATTRIBUTS ou ETAT

En Orienté-Objet, un objet est vu comme une entité qui encapsule un état interne (ensemble des valeurs des var. d’inst.) et qui fournit des services (méth. d’inst.)

par rapport à cet état.

4


Classes&objets: CONSTRUCTEURS, VARIABLES et METHODES D’INSTANCE

classe Dominom1 : intm2 : int


classe Book (anglicisée)

title : Stringautor : Stringeditor : StringnbPages : intisbn : ISBN

+Book(String,String,String,int,ISBN)

classe ISBN (anglicisée)

groupA : intgroupB : intgroupC : StringgroupD : String

+ISBN(int,int,String,String)

+dominoToString(): String+estDouble(): boolean+valeur(): int+plusGrandQue(Domino d): int+plusGrandeMarque(): int

+bookToString(): String+hasAutor(String firstname, String lastname): boolean+isFrancophone(): boolean+isEditedBy (String): boolean+isEditedBy(int): boolean

+isbnToString(): String+isFrancophone(): boolean+isEditedBy (int): boolean

classe MainDominoset classe MainBooks

+$main(String[]): void+$test1(): void+$test2(): void

FIRST NAME : prénom / LAST NAME : nom de famille / MIDDLE NAMES : autres prénoms

5Objectifs de ce cours (I21)


Maintenant !Maintenant !

6


Classes&objets : VÉRITABLES ENTITÉS AUTONOMES*

7


Classes&objets : le problème des ENSEMBLES d’OBJETS

8


COMMENT AVONS-NOUS TRAITÉ LES ENSEMBLES D’OBJETS JUSQUE LÀ ?

classe MainDominos

+$ main(String[]) { test1(); }+$ test1() { Domino[] miniJeu = { new Domino(0,0), new Domino(0,1), new Domino(0,2) }; System.out.println( "Jeu contenant " + miniJeu.length + " dominos");

System.out.println(setDominosToString(miniJeu));}+$ setDominosToString(Domino[] setDominos) { String s = ""; for( Domino d : setDominos ) {

s += d.dominoToString(); } return s;}

AGIT SUR LE TABLEAU DE

DOMINOS=> méthode d’instance

IMPOSSIBLE ici

AGIT SUR LE TABLEAU DE

DOMINOS=> méthode d’instance

IMPOSSIBLE ici

N’AGIT QUE SUR UN SEUL DOMINO

=> méthode d’instance de la classe Domino

N’AGIT QUE SUR UN SEUL DOMINO

=> méthode d’instance de la classe Domino

9


(A) CLASSE ENCAPSULANT UN TABLEAU D’OBJETS

Solution :

classe JeuDominos

Domino[] jeu; // le jeu de dominos // méthode d’instance

+String jeuDominosToString() { String s = "";

for( Domino d : this.jeu) { s += d.dominoToString(); } return s;}

+JeuDominos() // le constructeur

➽ Il reste à prévoir comment le jeu de dominos pourra être construit.

Le tableau de dominos étant une variable d’instance, l’accès se fait à l’aide de this

➽ Créer une classe spécifique pour contenir un ensemble de dominos sous la forme d’un tableau.

Ici, class JeuDominos par exemple

➽ Créer une classe spécifique pour contenir un ensemble de dominos sous la forme d’un tableau.

Ici, class JeuDominos par exemple

➽ Encapsuler le tableau de dominos dans la classe comme variable

d’instance.Ici, Domino[] jeu

➽ Encapsuler le tableau de dominos dans la classe comme variable

d’instance.Ici, Domino[] jeu

➽ Doter la classe des méthodes d’instance utiles.Ici, public String

jeuDominosToString()

➽ Doter la classe des méthodes d’instance utiles.Ici, public String

jeuDominosToString()

10



Solution :

classe JeuDominos

jeu:Domino[] // le tableau de dominos

// Méthodes d’instance qui crée un jeu

public void createJeuNormal(){ this.jeu = new Domino[28](); int n = 0; for( int m1=0 ; m1<=6 ; m1++) for( int m2=i ; m2<=6 ; m2++) // Placer un nouveau domino de // marque m1,m2 à la position n this.jeu[n++] = new Domino(m1,m2);}+jeuDominosToString():String

// Constructeur d’un jeu vide

public JeuDominos() { this.jeu = new Domino[0];}

➽ Construire un jeu de dominos vide pour commencer

➽ Construire un jeu de dominos vide pour commencer

Plusieurs solutions sont envisageables mais ici on préfèrera procéder ainsi :

Tableau vide (ZERO éléments)

On aurait aussi pu vouloir écrire : this.jeu = null;mais la méthode jeuDominosToString() n’aurait pas fonctionnée correctement dans le cas où le jeu n’aurait pas encore été créé.

➽ Ajouter une méthode d’instance qui crée un un jeu de dominos.

Ex: public void createJeuNormal()

➽ Ajouter une méthode d’instance qui crée un un jeu de dominos.

Ex: public void createJeuNormal()

11



Complément : Pour donner la possibilité de connaître facilement le nombre de dominos du jeu, on peut ajouter une nouvelle méthode d’instance.

➽ Il ne reste qu’à utiliser cette classe dans un applicatif.

classe JeuDominos

// le tableau de dominosjeu:Domino[]

// Méthodes d’instance+createJeuNormal():void+jeuDominosToString():String// Méthodes d’instance qui fournit// le nombre actuel de dominos du jeu

public int size(){ return this.jeu.length;}

// Constructeur d’un jeu vide+JeuDominos()

➽ Ajouter une méthode d’instance qui fournit le nombre de dominos du

jeu.Ex: public int size()

➽ Ajouter une méthode d’instance qui fournit le nombre de dominos du

jeu.Ex: public int size()

Cela permet d’éviter d’avoir à accéder au tableau de dominos depuis l’extérieur de

cette classe, en faisant :<unJeuDeDomino>.jeu.length

12



Applicatif : On veut construire puis afficher un jeu de dominos

classe JeuDominos

// Variable d’instancejeu:Domino[]

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

// Constructeur d’un jeu vide+JeuDominos()

classe MainDominos

+$ main(String[]) { test1(); }+$ test1() {

}

JeuDominos jeuNormal = new JeuDominos();

jeuNormal.createJeuNormal();System.out.println( "Jeu contenant " + jeuNormal.size() + " dominos");System.out.println(jeuNormal.jeuDominosToString());

① Créer un jeu de dominos vide

② Ajouter des dominos au jeu

③ Afficher le nombre de dominos du jeu

④ Afficher tous les dominos du jeu

①

②

③

④

Au final, on s’aperçoit que la classe MainDominos n’a plus besoin d’accéder directement au tableau de dominos (qui se trouve maintenant dans le jeu)

Ceci constitue une bonne pratique dans le paradigme

Orienté-Objet !

➽

Utilisations des méthodes d’instance de la classe JeuDominos

13


OBJECTIFS DU PARADIGME ORIENTÉ-OBJET

Ce que nous venons de mettre en œuvre est en parfait accordavec l’objectif du paradigme Orienté-Objet :

Un problème étant posé :➽ le décomposer en plusieurs petites entités plus simples (classes) :

=> faire apparaître des classes d’objets bien ciblées>>> leurs donner le maximum d’autonomie(en évitant qu’elles délèguent à d’autres ce qu’elles peuvent faire)

>>> leurs permettre d’être manipulées extérieurement le plusfacilement possible(en les dotant de méthodes d’instance utiles à la résolution globale)

➽ résoudre le problème global posé en faisant interagir ces entités entre elles :

=> ici, il ne s’agit plus que de manipuler les entités depuis l’extérieur

14



Quel est le champ d’utilisation des classes encapsulant des tableaux ?

Dans l’exemple traité (un jeu de dominos), nous n’avons fait que construire un jeu de dominos. Mais pour jouer aux dominos, il faudrait penser à :

la création de la pioche la distribution de dominos aux joueurs la constitution de la ligne de jeu

UN JEUEN COURS

Ce qui revient à partager le jeu initial en

sous-ensembles de dominosde tailles variables

la pioche (taille décroissante) la donne des joueurs (taille variable) la ligne de jeu (taille croissante)

+3-1+1

-3

15



Lorsque la taille des ensembles d’objets est variable,

cela induit un ASPECT DYNAMIQUE.

Cet aspect dynamique complique la gestion des tableaux car ceux-ci sont des

STRUCTURES DE DONNÉES STATIQUES.

➽ les classes encapsulant des ensembles d’objets de taille variable ont donc pour travail de rendre dynamique une

structure de donnée normalement statique.

➽ La pioche perd 3 dominos

pioche = new Domino[14-3]

➽ La pioche perd 3 dominos

pioche = new Domino[14-3]

➽ La donne contient 2 dominos de plus

donne = new Domino[4+3-1]

➽ La donne contient 2 dominos de plus

donne = new Domino[4+3-1]

➽ La ligne de jeu gagne 1 domino

ligneDeJeu = new Domino[4+1]

➽ La ligne de jeu gagne 1 domino

ligneDeJeu = new Domino[4+1]

16



De quelles méthodes faudrait-il disposer pour que les classes qui encapsulent des ensembles d’objets variables soient facilement utilisables de l’extérieur ?

classe Pioche

// Variable d’instancelaPioche:Domino[]

// Méthodes d’instance+piocheToString():String

// Constructeur de pioche vide

① Pouvoir créer une pioche vide (constructeur)

② Pouvoir ajouter un domino à la pioche

③ Pouvoir ajouter plusieurs dominos en une fois

④ Pouvoir tester si la pioche est vide①

②③④

⑤ Pouvoir connaître le nombre de dominos de la pioche

⑥ Pouvoir piocher un domino aléatoirement

L’exemple de la pioche

+Pioche()

+add(Domino d):void+add(Domino[] setDominos):void+isEmpty():boolean+size():int⑤

⑥ +piocheUnDomino():Domino

➽ Il ne reste qu’à écrire ces méthodes d’instance

On se basera sur un constructeur qui initialise la variable d’instance à null

(fait pendant le cours)

17



classe DonneJoueur

// Variable d’instancelaDonne:Domino[]

// Méthodes d’instance+donneToString():String

// Constructeur de donne vide

① Pouvoir créer une donne vide (constructeur) ② Pouvoir ajouter un domino à la donne

C’est le jeu de dominos qui pourrait distribuer les dominos aux joueurs

③ Pouvoir ajouter plusieurs dominos en une foisIdem mais en fournissant tous les dominos d’un coup (par exemple)

④ Pouvoir tester si la donne est videCe peut être utile pour savoir si le joueur a gagné (le jeu doit terminer)

①

②③④

⑤ Pouvoir connaître le nombre de dominos de la donne ⑥ Pouvoir extraire un domino choisi par son rang

Ce peut être utile pour permettre au joueur de jouer un certain domino

⑦ Pouvoir extraire un domino choisi par sa référenceIdem mais en désignant le domino par sa référence d’objet

⑧ Pouvoir faire jouer le joueur sur la base d’une pioche et d’une ligne de jeuCette méthode permettrait à un joueur de « demander » à sa donne de jouer un domino relativement à une pioche et une ligne de jeu

⑨ Pouvoir retrouver le plus grand domino jouableCette méthode permettrait d’adopter une stratégie de jeu qui tente de jouer le plus gros domino de la donne compte tenu d’une ligne de jeu

⑩ Etc.

L’exemple de la donne des joueurs

+DonneJoueur()

+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

...

18



classe LigneDeJeu

// Variable d’instanceldj:Domino[]

// Méthodes d’instance+donneToString():String

// Constructeur de donne vide

① Pouvoir créer une ligne de jeu vide (constructeur) ② Pouvoir ajouter un domino à droite de la ligne de jeu

Permet aux joueurs d’ajouter un domino à droite d’une la ligne de jeu

③ Pouvoir ajouter un domino à gauche de la ligneIdem mais à gauche

④ Pouvoir tester si la ligne de jeu est videCe peut être utile pour savoir si on doit jouer un double (début de jeu)

①

②③④

⑤ Pouvoir connaître le nombre de dominos de la donne ⑥ Pouvoir connaître un domino choisi par son rang

Peut être utile pour permettre au joueur d’adopter une stratégie de jeu

⑦ Pouvoir connaître un domino choisi par sa référenceIdem mais en désignant le domino par sa référence d’objet

⑧ Savoir si un domino est jouable à droite de la ligne de jeuPermettrait à un joueur de « demander » à la ligne de jeu si un certain domino peut y être accolé à droite

⑨ Savoir si un domino est jouable à droite de la ligne de jeuIdem mais à gauche

⑩ etc.

L’exemple de la ligne de jeu

+DonneJoueur()

+addToRight(Domino d):boolean+addToLeft(Domino d):boolean+isEmpty():boolean+size():int⑤

⑥⑦⑧

⑨

⑩

+getDomino(int rg):Domino+getDomino(Domino d):Domino+isAccolableToRight(Domino d):boolean+isAccolableToLeft(Domino d):boolean

...

19



A travers ces exemples, on voit apparaître des classes dotées de méthodes d’instance dont le rôle est de fournir des fonctionnalités utiles aux objets qui les instancient.

Les trois classes ensemblistes (Pioche, Donne et LigneDeJeu) doivent interagir car elles participent à un même objectif de jeu. Chacune représente une part du programme de jeu de dominos.A la base, la classe JeuDominos devrait instancier une pioche , une ligne de jeu et des joueurs, eux-mêmes instanciant leur propre donne.

Finalement, la classe JeuDominos jouent le rôle de chef d’orchestre pour l’application. Au départ, c’est d’elle que (1) le jeu sera construit puis que (2) le jeu se déroulera en délégant aux autres objets la plupart des fonctionnalités du jeu :

1 objet JeuDominos 1 objet LigneDeJeu

1 objet Pioche

1 table de Joueurs1 objet Donne

1 objet Donne1 objet Donne

1 objet Joueur1 objet Joueur

1 objet Joueur

contient

contient contient

20

retours

➽ Rechercher le meilleur coup

(en utilisant la pioche, la ligne de jeu et en utilisant une stratégie éventuel-

lement définie par le joueur)

➽ Rechercher le meilleur coup

(en utilisant la pioche, la ligne de jeu et en utilisant une stratégie éventuel-

lement définie par le joueur)



On voit ici tout l’intérêt du premier concept de l’Orienté-Objet :Les objets encapsulent des données et des méthodes agissant sur leurs données

➽A partir de là, il est possible de déléguer les fonctionnalitésaux objets qui savent le mieux les réaliser.

Pour que le jeu se déroule, c’est de la classe JeuDominos qu’une méthode d’instance devra faire jouer les joueurs à tour de rôle jusqu’à la fin de la partie.Mais le fait de jouer un coup sera délégué à chaque joueur. Et enfin, la délégation se poursuit vers la donne, la pioche et la ligne de jeu.

➽ Faire jouer les joueurs à tour de rôle(simple boucle qui délègue aux joueurs le fait de jouer en leur donnant une pioche

et une ligne de jeu)

➽ Faire jouer les joueurs à tour de rôle(simple boucle qui délègue aux joueurs le fait de jouer en leur donnant une pioche

et une ligne de jeu)

➽ Faire jouer ce joueur

(en donnant une pioche et une ligne de jeu)

➽ Faire jouer ce joueur

(en donnant une pioche et une ligne de jeu)

délégationdélégation

retour

délégation

délégation

1 objet Donne1 objet Donne

1 objet JeuDominos 1 objet LigneDeJeu

1 objet Pioche

1 table de Joueurs 1 objet Joueur1 objet Joueur1 objet Joueur 1 objet Donne

retour

contient

contient contient

21


PROTECTION DE L’ÉTAT INTERNE DES OBJETS

Jusqu’à présent nous avons laissé libre l’accès à l’état des objets depuis l’extérieur.

Cela revient à exposer l’état interne des objets (valeurs des variables d’instance) vers l’extérieur.Si cette pratique peut paraître utile, elle est en réalité très dangereux

et va à l’encontre du paradigme Orienté-Objet.

➽ Pourquoi cela est-il dangereux ?Quand une classe utilise un objet externe, le fait d’accéder directement à l’état interne de cet objet lui confère la possibilité de le modifier à sa guise.

Par exemples : un joueur qui possède une donne pourrait modifier les dominos qu’elle contient !?! un joueur qui connaît la pioche peut en profiter pour piocher les dominos qui l’intéressent !?!

➽ Cela serait-il un problème ?On pourrait dire « non » puisque, si le code était fait de sorte qu’un joueur puisse piocher les dominos qui l’intéressent, cela se produirait pour TOUS les joueurs.Tout au plus, le programme tricherait mais, trichant pour tous les joueurs, il y aurait peu d’intérêt à écrire une tel programme.

22


PROTECTION DE L’ÉTAT INTERNE DES OBJETS

➽ Quel est le vrai problème ?En fait, il s’agit plus d’un problème de mauvaise conception des programmes.Dans le paradigme OO, ce que l’on désire avant tout c’est de structurer les programmes de sorte qu’ils soient facile à écrire, à comprendre, à corriger, à maintenir et à faire évoluer. Or, si l’on effectue de l’extérieur une partie des comportements normalement attendus dans une classe, il va vite devenir difficile de repérer tous les endroits où des modifications peuvent survenir sur un objet.L’écriture, la lecture, la correction, la maintenance et l’évolution en seront d’autant plus ardues.

➽ Quel est donc le point de vu de l’OO ?Le paradigme OO nous incite à respecter un point fondamental :

« Ne pas faire faire à un objet ce qu’un autre saurait mieux faire. » Le joueur n’a pas à piocher directement dans la pioche, il doit utiliser une méthode d’instance de la pioche La pioche ne doit pas déléguer le fait de piocher

On peut aussi dire : « Ne pas déléguer à d’autres ce que l’on sait fairemais ne pas faire ce que d’autres feraient mieux. »

Seule la pioche doit permettre de piocher un domino pour assurer que cela est bien fait aléatoirement ! Seule la ligne de jeu peut accepter un domino à l’une de ses extrémités pour assurer que le domino est jouable !

23


PROTECTION DE L’ÉTAT INTERNE DES OBJETS (SUITE)

Ainsi le paradigme Orienté-Objet nous incite à voir les choses autrement :

➽ L’état interne d’un objet doit rester de la responsabilité de l’objet lui-mêmePar exemples : seule la pioche peut fournir un domino avec l’assurance qu’il ait été pioché au hasard ! seule une ligne de jeu peut accepter un domino à l’une de ses extrémités avec l’assurance qu’il puisse y

être joué !

➽ Pourquoi ?1) c’est là un principe qui permet de garantir la cohérence constante de l’état interne des objets(on est assuré que la ligne de jeu ne comportera jamais de dominos mal placés)

2) c’est aussi ce qui rend les programmes OO faciles à maintenir, à corriger ou à faire évoluer(on sait facilement repérer les erreurs dans les programmes puisqu’une incohérence dans l’état d’un objet ne pourrait provenir que de l’objet lui-même – i.e. de ces méthodes d’instance)

➽ Comment ?1) les objets doivent protéger leurs états internes de l’extérieur en n’autorisant pas leur accès

Cela est réalisé en déclarant les variables d’instance comme privées (ex: private int m1, m2;)

2) en contrepartie, les classes doivent fournir TOUTES les méthodes d’instance permettant de manipuler leurs objets depuis l’extérieur

24


PROTECTION DE L’ÉTAT INTERNE DES OBJETS (SUITE)

classe Domino// Variables d’instance privées-m1: int-m2: int

classe Pioche// Variable d’instance privée-laPioche: Domino[]

classe LigneDeJeu// Variable d’instance privée-ldj: Domino[]

classe DonneJoueur// Variable d’instance privée-laDonne: Domino[]

➽ Déclarations Java :// Variables d’instance

privées

private int m1, m2;

private Domino[] laPioche;

private Domino[] ldj;

private Domino[] laDonne;

➽ Déclarations Java :// Variables d’instance

privées

private int m1, m2;

private Domino[] laPioche;

private Domino[] ldj;

private Domino[] laDonne;

25



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)

26


Acta est fabula

Documents

1 Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde COURS 3 : Programmation impérative Résumé du cours précédent