fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Au programme

Conception Orientée Objet

Jean-Christophe Routier
Licence mention Informatique
Université Lille – Sciences et Technologies

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 1
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Présentation

l’UE COO est le prolongement immédiat de l’UE POO du S4 informatique.

cf. http://portail.fil.univ-lille1.fr/portail/ls4/poo

après la programmation... la conception

comment utiliser les concepts objets pour construire des logiciels.

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 2
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

fonctionnement

équipe pédagogique
Bilel Derbel, Thomas Dupriez, Brandon Foubert, Jérémy Lictevout,
Clément Quinton, Jean-François Roos, Yves Roos, Romain Rouvoy,
Jean-Christophe Routier
1h30 de Cours (8 séances), 2h TD, 1h30 TP par semaine
préparer les TD, être acteur !
évaluation continue :
TP à rendre
première session : T P +sup(DS1+2∗DS2,3∗DS2)
4
seconde session : note TP conservée, T P +3×DS3
4

http://portail.fil.univ-lille1.fr/portail/ls5/coo

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 3
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

A l’issue de ce module vous devriez...

maı̂triser les concepts de la programmation objet :

maitriser les différentes manières de mettre en œuvre le polymorphisme ;
connaı̂tre quelques principes de conception objet et savoir les mettre en
œuvre ;
être en mesure de concevoir une application avec une approche
objet :
savoir faire une analyse objet d’un problème complexe et faire les choix
de conception appropriés en utilisant de manière pertinente les concepts
et principes des langages à objets ;
connaı̂tre les principaux patrons de conception (« design patterns »),
être en mesure d’identifier des situations où ils s’appliquent et les mettre
en œuvre ;
adopter une méthodologie de conception rigoureuse : documenter un
programme, écrire et utiliser des tests ;

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 4
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Pré-requis objet

classes et objets
instances, constructeurs, méthodes, attributs
UML comme notation : diagrammes de classes
modélisation objet d’un problème
analyse d’un problème simple, identification des classes et leur
conception,
polymorphisme des objets
les interfaces, l’héritage,
mécanismes de lookup et liaison tardive (late-binding)

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 5
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Pré-requis java
class, this, private, public
toString, equals/==
static, enum
interface, extends, super
exceptions : capture et levée
try ... catch, throws/throw
java.util :
Collection<E>, Iterator, Iterable
List/ArrayList/LinkedList, Set,
Map/HashMap, hashCode

package, import
javac, java, jar, javadoc, classpath, tests (JUnit)
,→ “Le TP4” de POO à (re)faire (voir semainier)
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 6
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Un jeu de plateau simple :

une piste constituée de cases numérotées de différentes couleurs ;
les joueurs sont représentés chacun par un pion de couleurs différentes,
ces couleurs sont éventuellement les mêmes que celles des cases.
Chaque joueur a 3 vies en début de partie ;
les joueurs jouent chacun leur tour en lançant deux dés et en avançant
d’autant de cases ;
lorsqu’un joueur s’arrête sur une case, la conséquence est qu’il marque
des points et la case produit un effet. Les points marqués sont doublés
si la couleur du joueur est la même que celle de la case. Le nombre de
points marqués et l’effet varient en fonction de la couleur de la case.
Certaines cases font marquer plus de points, d’autre perdre des vies,
etc.
le jeu se termine quand un joueur a marqué plus qu’un nombre de
points fixé à l’avance ou quand tous les joueurs sauf un ont perdu
toutes leurs vies.
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 7
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Player
- currentSquare : Square
- nbPoints :int Square
- nbLives : int - index : int
Game
- color : Color - players : List<Player>
- players : List<Player>
+ Player(c: Color) - color : Color
- allSquares : Square[]
+ getSquare() : Square + Square(idx :int, c : Color)
- currentPlayer : Player
+ setSquare(s : Square) + getIndex() : int
+ Game()
+ getPoints() : int + getColor() : Color
+ addPlayer(p: Player)
+ getColor() : Color + addPlayer(p : Player)
+ play()
+ getNbLives() : int + removePlayer(p : Player)
...
+ addPoints(pts : int) + consequence(p : Player)
+ receiveOnLife() ...
+ loseOneLife()
...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 8
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Player
- currentSquare : Square
- nbPoints :int Square
- nbLives : int - index : int
Game
- color : Color - players : List<Player>
- players : List<Player>
+ Player(c: Color) - color : Color
- allSquares : Square[]
+ getSquare() : Square + Square(idx :int, c : Color)
- currentPlayer : Player
+ setSquare(s : Square) + getIndex() : int
+ Game()
+ getPoints() : int + getColor() : Color
+ addPlayer(p: Player)
+ getColor() : Color + addPlayer(p : Player)
+ play()
+ getNbLives() : int + removePlayer(p : Player)
...
+ addPoints(pts : int) + consequence(p : Player)
+ receiveOnLife() ...
+ loseOneLife()
...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 8
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

dans la classe Game :

/∗∗ . . . ∗/
public void play() {
Iterator<Player> p l a y e r I t = this . players . i t e r a t o r ( ) ;
boolean fin ished = f a l s e ;
while ( ! finis hed ) {
i f ( ! p l a y e r I t . hasNext ()) {
p l a y e r I t = this . players . i t e r a t o r ( ) ;
}
this . currentPlayer = p l a y e r I t . next ( ) ;
int dice = this . currentPlayer . throwDice ( ) ;
int currentSquareIndex = this . currentPlayer . getSquare ( ) . getIndex ( ) ;
int nextSquareIndex = currentSquareIndex+dice ;
Square nextSquare = this . allSquares [ nextSquareIndex ] ;
this . currentPlayer . getSquare ( ) . removePlayer( this . currentPlayer ) ;
this . currentPlayer . setSquare (nextSquare ) ;
nextSquare . addPlayer( this . currentPlayer ) ;
nextSquare . consequence( this . currentPlayer ) ;
i f ( this . currentPlayer . getNbLives () < 0) {
this . players . remove( this . currentPlayer ) ;
}
fin ished = this . currentPlayer . getNbPoints () > 1000 | | this . players . s i z e () == 1;
}
Player winner ;
i f ( this . players . s i z e () == 1) {
winner = this . players . get (0);
} else {
winner = this . currentPlayer ;
}
System . out . p r i n t l n ("the winner is "+winner ) ;
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 9
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

arghhhh...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 10
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public void play () {

Iterator<Player> p l a y e r I t = this . players . i t e r a t o r ( ) ;
boolean fin ishe d = f a l s e ;
while ( ! finis hed ) {
// compute next player
i f ( ! p l a y e r I t . hasNext ()) {
p l a y e r I t = this . players . i t e r a t o r ()
}
this . currentPlayer = p l a y e r I t . next ( ) ;
// compute new player ’ s square
int dice = this . currentPlayer . throwDice ( ) ;
int currentSquareIndex = this . currentPlayer . getSquare ( ) . getIndex ( ) ;
int nextSquareIndex = currentSquareIndex+dice ;
Square nextSquare = this . allSquares [ nextSquareIndex ] ;
// move player
this . currentPlayer . getSquare ( ) . removePlayer( this . currentPlayer ) ;
this . currentPlayer . setSquare (nextSquare ) ;
nextSquare . addPlayer( this . currentPlayer ) ;
// apply new square ’ s consequence
nextSquare . consequence( this . currentPlayer ) ;
// end of game i s reached ???
i f ( this . currentPlayer . getNbLives () < 0) {
this . players . remove( this . currentPlayer ) ;
}
fin ishe d = this . currentPlayer . getNbPoints () > 1000 | | this . players . s i z e () == 1;
}
// who i s the winner ?
Player winner ;
i f ( this . players . s i z e () == 1) {
winner = this . players . get (0);
} else {
winner = this . currentPlayer ;
}
System . out . p r i n t l n ("the winner is "+ winner ) ;
}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 11
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public void play () {

Iterator<Player> p l a y e r I t = this . players . i t e r a t o r ( ) ;
boolean fin ishe d = f a l s e ;
while ( ! finis hed ) {
// compute next player
i f ( ! p l a y e r I t . hasNext ()) {
p l a y e r I t = this . players . i t e r a t o r ()
}
this . currentPlayer = p l a y e r I t . next ( ) ;
// compute new player ’ s square
int dice = this . currentPlayer . throwDice ( ) ;
int currentSquareIndex = this . currentPlayer . getSquare ( ) . getIndex ( ) ;
int nextSquareIndex = currentSquareIndex+dice ;
Square nextSquare = this . allSquares [ nextSquareIndex ] ;
// move player
this . currentPlayer . getSquare ( ) . removePlayer( this . currentPlayer ) ;
this . currentPlayer . setSquare (nextSquare ) ;
nextSquare . addPlayer( this . currentPlayer ) ;
// apply new square ’ s consequence
nextSquare . consequence( this . currentPlayer ) ;
// end of game i s reached ???
i f ( this . currentPlayer . getNbLives () < 0) {
this . players . remove( this . currentPlayer ) ;
}
fin ishe d = this . currentPlayer . getNbPoints () > Game.WINNING POINTS | | this . players . s i z e () == 1;
}
// who i s the winner ?
Player winner ;
i f ( this . players . s i z e () == 1) {
winner = this . players . get (0);
} else {
winner = this . currentPlayer ;
}
System . out . p r i n t l n ("the winner is "+ winner ) ;
}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 12
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

re arghhhh...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 13
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

décomposer

il faut

dé-com-po-ser

responsabilité unique

une méthode, une fonctionnalité

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 14
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public void play () {

Iterator<Player> p l a y e r I t = this . players . i t e r a t o r ( ) ;
boolean fin ishe d = f a l s e ;
while ( ! finis hed ) {
// compute next player
i f ( ! p l a y e r I t . hasNext ()) {
p l a y e r I t = this . players . i t e r a t o r ()
}
this . currentPlayer = p l a y e r I t . next ( ) ;
// compute new player ’ s square
int dice = this . currentPlayer . throwDice ( ) ;
int currentSquareIndex = this . currentPlayer . getSquare ( ) . getIndex ( ) ;
int nextSquareIndex = currentSquareIndex+dice ;
Square nextSquare = this . allSquares [ nextSquareIndex ] ;
// move player
this . currentPlayer . getSquare ( ) . removePlayer( this . currentPlayer ) ;
this . currentPlayer . setSquare (nextSquare ) ;
nextSquare . addPlayer( this . currentPlayer ) ;
// apply new square ’ s consequence
nextSquare . consequence( this . currentPlayer ) ;
// end of game i s reached ???
i f ( this . currentPlayer . getNbLives () < 0) {
this . players . remove( this . currentPlayer ) ;
}
fin ishe d = this . currentPlayer . getNbPoints () > Game.WINNING POINTS | | this . players . s i z e () == 1;
}
// who i s the winner ?
Player winner ;
i f ( this . players . s i z e () == 1) {
winner = this . players . get (0);
} else {
winner = this . currentPlayer ;
}
System . out . p r i n t l n ("the winner is "+ winner ) ;
}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 15
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public void play () {

while ( ! finis hed ) {

// compute next player

// compute new player ’ s square

// move player

// apply new square ’ s consequence

nextSquare . consequence( this . currentPlayer ) ;
// end of game i s reached ???

fin ishe d =

}
// who i s the winner ?

}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 16
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

et donc...

public void play () {

while ( ! this . isFinished ()) { // end of game i s reached ???
this . currentPlayer = this . nextPlayer ( ) ; // compute next player
Square nextSquare = this . computeNextSquare ( ) ; // compute new player ’ s square
this . moveCurrentPlayer(nextSquare ) ; // move player
nextSquare . consequence( this . currentPlayer ) ; // apply new square ’ s consequence
}
this . displayWinner ( ) ; // who i s the winner ?
}

une seule responsabilité :

gérer la « boucle principale » du jeu

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 17
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

avec :
protected boolean isFinished () { responsabilité : déterminer si le jeu est fini
i f ( this . currentPlayer . getNbLives () < 0) {
this . players . remove( this . currentPlayer ) ;
}
return this . currentPlayer . getNbPoints () > WINNING POINTS | | this . players . s i z e () == 1;
}

protected Player nextPlayer () { . . . } responsabilité : choisir le prochain joueur

protected Square computeNextSquare() { responsabilité : calculer nouvelle case du joueur
int dice = this . currentPlayer . throwDice ( ) ;
int currentSquareIndex = this . currentPlayer . getSquare ( ) . getIndex ( ) ;
return this . allSquares [ currentSquareIndex+dice ] ;
}

protected void moveCurrentPlayer(Square nextSquare) { responsabilité : déplacer le joueur

this . currentPlayer . getSquare ( ) . removePlayer( this . currentPlayer ) ;
this . currentPlayer . setSquare (nextSquare ) ;
nextSquare . addPlayer( this . currentPlayer ) ;
}

public void displayWinner () { responsabilité : afficher le vainqueur

Player winner ;
i f ( this . players . s i z e () == 1) {
winner = this . players . get (0);
} else {
winner = this . currentPlayer ;
}
System . out . p r i n t l n ("the winner is "+ winner ) ;
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 18
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

cool...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 19
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

consequence

lorsqu’un joueur s’arrête sur une case, la conséquence est qu’il marque
des points et la case produit un effet. Les points marqués sont doublés
si la couleur du joueur est la même que celle de la case. Le nombre de
points marqués et l’effet varient en fonction de la couleur de la case.
Certaines cases font marquer plus de points, d’autre perdre des vies,
etc.
Si la couleur de la case est :
bleu, le joueur marque 100 points et reçoit un bonus entre 10 et 50
points
jaune, le joueur marque 50 points et gagne une vie
orange, la conséquence est le double de celle d’une case jaune
rouge, le joueur marque -100 points et perd une vie

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 20
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

nextSquare.consequence(this.currentPlayer);

consequence doit (« contrat »)

ajouter au joueur le nombre points correspondant à la case (points
doublés si les couleurs correspondent)
afficher le nombre de points gagnés
appliquer l’effet correspondant à la couleur de la case
indiquer si le joueur a perdu toutes ses vies

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 21
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

dans Square :
/∗∗ add points to the player and apply square e f f e c t . Points and e f f e c t depend
∗ on square color . Won points are d i s p l a i d and player i s n o t i f i e d i f ( s )he has
∗ lost a l l its lives .
∗ @param player the player reaching t h i s square
∗/
public void consequence( Player player ) {
// points management
int points = this . getNbPoints ( ) ;
i f ( player . getColor ( ) . equals ( this . color )) { // double points i f same color
points = 2 ∗ points ;
}
player . addPoints( points ) ;
System . out . p r i n t l n ( player+" gets "+points ) ;

// apply the square e f f e c t

i f ( this . color == Color .BLUE) {
player . addPoints( alea . nextInt (40)+10);
} else i f ( this . color.equals( Color .YELLOW)) {
player . receiveOneLife ( ) ;
} else i f ( this . color == Color .ORANGE) {
player . receiveOneLife ( ) ;
player . receiveOneLife ( ) ;
} else i f ( this . color == Color .RED) {
player . loseOneLife ( ) ;
}

// has the player l o s t a l l i t s l i v e s ?

i f ( player . getNbLives () <= 0) {
System . out . p r i n t l n ( player +" is eliminated, no more life" ) ;
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 22
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

arghhhh...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 23
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

évolution

ajout d’une nouvelle couleur de case

si la couleur de la case est :
noir, le joueur perd deux vies

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 24
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

plusieurs comportements ⇒ plusieurs types

polymorphisme + late-binding

différents types de Square

Square
- index : int
- players : List<Player>
- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 25
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Squares

différents types de cases :

différentes classes: BlueSquare, YellowSquare, etc.
doivent posséder la même interface publique
= répondent aux mêmes messages
⇒ doivent partager un type commun (Square)
partagent des comportements (getColor, addPlayer,...)
partagent des attributs (index, players, color)
diffèrent sur les comportements de consequence Square
- index : int
pas de « comportement par défaut » - players : List<Player>
- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 26
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Squares

différents types de cases :

différentes classes: BlueSquare, YellowSquare, etc.
doivent posséder la même interface publique
= répondent aux mêmes messages
⇒ doivent partager un type commun (Square)
partagent des comportements (getColor, addPlayer,...)
partagent des attributs (index, players, color)
diffèrent sur les comportements de consequence Square
- index : int
pas de « comportement par défaut » - players : List<Player>
- color : Color
+ Square(idx :int, c : Color)
classe abstraite + héritage + getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 26
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 27
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public class BlueSquare extends Square {

public class YellowSquare extends Square {
private static f i n a l Random alea = new Random( ) ;
private static f i n a l int YELLOW POINTS = 50;
private static f i n a l int BLUE POINTS = 100;
public YellowSquare( int index ) {
public BlueSquare( int index ) {
super( index , Color .YELLOW) ;
super( index , Color .BLUE) ;
}
}
public void consequence( Player player ) {
public void consequence( Player player ) {
// points management
// points management
int points = YELLOW POINTS;
int points = BLUE POINTS;
i f ( player . getColor () == this . color ) {
i f ( player . getColor () == this . color ) {
points = 2 ∗ points ;
points = 2 ∗ points ;
}
}
player . addPoints( points ) ;
player . addPoints( points ) ;
System . out . p r i n t l n ( player+" gets "+points ) ;
System . out . p r i n t l n ( player+" gets "+points ) ;
// apply the square e f f e c t
// apply the square e f f e c t
player . receiveOneLife ( ) ;
player . addPoints( alea . nextInt (40)+10);
// has the player l o s t a l l i t s l i v e s ?
// has the player l o s t a l l i t s l i v e s ?
i f ( player . getNbLives () <= 0) {
i f ( player . getNbLives () <= 0) {
System . out . p r i n t l n ( player +" is ...")
System . out . p r i n t l n ( player +" is ..." ) ;
}
}
}
}
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 28
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

si la couleur de la case est :

orange, la conséquence est le double de celle d’une case jaune

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 29
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

si la couleur de la case est :

orange, la conséquence est le double de celle d’une case jaune

public class YellowSquare extends Square { public class Orange Square extends Square {
private static f i n a l int YELLOW POINTS = 50; private static f i n a l int ORANGE POINTS = 100 ;

public YellowSquare( int index ) { public OrangeSquare( int index ) {

super( index , Color .YELLOW) ; super( index , Color .ORANGE) ;
} }

public void consequence( Player player ) { public void consequence( Player player ) {
// points management // points management
int points = YELLOW POINTS; int points = ORANGE POINTS;
i f ( player . getColor () == this . color ) { i f ( player . getColor () == this . color ) {
points = 2 ∗ points ; points = 2 ∗ points ;
} }
player . addPoints( points ) ; player . addPoints( points ) ;
System . out . p r i n t l n ( player+" gets "+points ) ; System . out . p r i n t l n ( player+" gets "+points ) ;

// apply the square e f f e c t // apply the square e f f e c t

player . receiveOneLife ( ) ; player.receiveOneLife() ;
player.receiveOneLife() ;
// has the player l o s t a l l i t s l i v e s ? // has the player l o s t a l l i t s l i v e s ?
i f ( player . getNbLives () <= 0) { i f ( player . getNbLives () <= 0) {
System . out . p r i n t l n ( player +" is ...") System . out . p r i n t l n ( player +" is ..." ) ;
} }
} }
} }

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 30
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

arghhhh...

évolution du code de YellowSquare ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 31
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

si la couleur de la case est :

orange, la conséquence est le double de celle d’une case jaune

utiliser super

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 32
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public class OrangeSquare extends YellowSquare {

public OrangeSquare( int index ) {

super( index ) ;
this . color = Color .ORANGE;
}

public void consequence( Player player ) {

super . consequence( player ) ;
super . consequence( player ) ;
}

respect du contrat :
« la conséquence d’une case orange est le double de celle d’une case jaune »

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 33
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

évolution

ajout d’une nouvelle couleur de case

si la couleur de la case est :
noir, le joueur perd deux vies

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 34
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 35
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Principe ouvert-fermé

Open Close Principle

Un code doit être ouvert aux extensions et fermé aux modifications.

il doit être possible d’étendre l’application sans modifier le code existant

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 36
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

late binding

public void play() {

...
Square nextSquare = this.computeNextSquare();
...
nextSquare.consequence(this.currentPlayer);
...
}

quel code est appelé ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 37
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

late binding

public void play() {

...
Square nextSquare = this.computeNextSquare();
...
nextSquare.consequence(this.currentPlayer);
...
}

quel code est appelé ?

si nextSquare fait référence à un objet
YellowSquare ?
BlueSquare ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 37
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

late binding

public void play() {

...
Square nextSquare = this.computeNextSquare();
...
nextSquare.consequence(this.currentPlayer);
...
}

quel code est appelé ?

si nextSquare fait référence à un objet
YellowSquare ?
BlueSquare ?
late-binding
lookup
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 37
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public static void main( String [ ] args ) {

List<A> l i s t e A = new ArrayList<A>();
l i s t e A . add(new B( ) ) ;
l i s t e A . add(new C( ) ) ;

for (A a : l i s t e A ) {
System . out . p r i n t l n ("- appel h() -" ) ;
a.h();
System . out . p r i n t l n ("- appel f() -" ) ;
a. f ();
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 38
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

lookup

this est une référence vers l’objet qui reçoit le message : celui qui
invoque la méthode

Recherche (“lookup”) :
méthode publique :
la recherche commence dans la classe de l’objet invoquant
si aucune définition de la méthode n’est trouvée, on continue la
recherche dans la super-classe
et ainsi de suite
la recherche de la méthode est donc dynamique
si le message porte sur une méthode privée de la classe du receveur :
on prend la définition de la méthode dans la classe où est réalisée l’envoi
de message. Dans ce cas le choix est statique.

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 39
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

lookup avec super

super est une référence vers l’objet qui reçoit le message (“invoquant”)
super == this
Mais, recherche de méthode (lookup) avec super différente :
méthode publique :
la recherche commence dans la super-classe de la classe définissant
la méthode utilisant super
le processus de chaı̂nage reste ensuite le même à partir de cette classe
super ne fait pas commencer la recherche de méthode dans la
super-classe de l’objet

this est dynamique, super est statique

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 40
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

factorisation de code
public abstract class Square {
...
public abstract void consequence( Player player ) ;
}

public class YellowSquare extends Square { public class BlueSquare extends Square} {
... ...
public void consequence( Player player ) { public void consequence( Player player ) {
// points management // points management
int points = 50; int points = 100;
i f ( player . getColor ( ) . equals ( this . color )) { i f ( player . getColor ( ) . equals ( this . color )) {
points = 2 ∗ points ; points = 2 ∗ points ;
} }
player . addPoints( points ) ; player . addPoints( points ) ;
System . out . p r i n t l n ( player+" gets "+points ) ; System . out . p r i n t l n ( player+" gets "+points ) ;

// apply the square e f f e c t // apply the square e f f e c t

player . receiveOneLife ( ) ; player . addPoints( alea . nextInt (40)+10);

// has the player l o s t a l l i t s l i v e s ? // has the player l o s t a l l i t s l i v e s ?

i f ( player . getNbLives () <= 0) { i f ( player . getNbLives () <= 0) {
System . out . p r i n t l n ( player +" is ...") System . out . p r i n t l n ( player +" is ..." ) ;
} }
} }
} }

duplication de code... + similaire dans BlackSquare, RedSquare

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 41
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

dans le contrat de consequence

ajouter au joueur le nombre points correspondant à la case
(points doublés si les couleurs correspondent)
afficher le nombre de points gagnés
appliquer l’effet correspondant à la couleur de la case
indiquer si le joueur a perdu toutes ses vies
seuls le nombre de points et l’application de l’effet changent d’un type à
l’autre

Comment le prendre en compte et garantir que le contrat sera

? toujours respecté ?

y compris par les classes non encore écrites...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 42
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

il faut séparer ce qui change de ce qui ne varie pas

Comment ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 43
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

il faut séparer ce qui change de ce qui ne varie pas

Comment ? BlueSquare
public void consequence(Player player) {
// points management
int points = 100;
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
player.addPoints(alea.nextInt(40)+10);;
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 43
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

il faut séparer ce qui change de ce qui ne varie pas

Comment ? YellowSquare
public void consequence(Player player) {
// points management
int points = 50;
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
player.receiveOneLife();
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 43
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

il faut séparer ce qui change de ce qui ne varie pas

Comment ? tous les Square

public void consequence(Player player) {
// points management
int points = *************;
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
**************************;
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 43
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

il faut séparer ce qui change de ce qui ne varie pas

Comment ? tous les Square

public void consequence(Player player) {
// points management
int points = this.getNbPoints();
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
this.applyEffect(player);
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 43
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

utiliser les « outils » à disposition pour consolider le contrat

public abstract class Square {

...
public void consequence(Player player) {
// points management
int points = this.getNbPoints();
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
this.applyEffect(player);
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

abstract int getNbPoints();

abstract void applyEffect(Playerplayer);
}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 44
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

utiliser les « outils » à disposition pour consolider le contrat

public abstract class Square {

...
public void consequence(Player player) {
// points management
int points = this.getNbPoints();
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
this.applyEffect(player);
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

public abstract int getNbPoints();

protected abstract void applyEffect(Playerplayer);
}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 44
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

utiliser les « outils » à disposition pour consolider le contrat

public abstract class Square {

...
public final void consequence(Player player) {
// points management
int points = this.getNbPoints();
if (player.getColor().equals(this.color)) {
points = 2 * points;
}
player.addPoints(points);
System.out.println(player+" gets "+points);
// apply the square effect
this.applyEffect(player);
// has the player lost all its lives ?
if (player.getNbLives() <= 0) {
System.out.println(player +" is ...");
}
}

public abstract int getNbPoints();

protected abstract void applyEffect(Playerplayer);
}
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 44
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

public class YellowSquare extends Square {

public class BlueSquare extends Square {
...
...
public int getNbPoints() {
public int getNbPoints() {
return 100;
return 50;
}
}
protected void applyEffect( Player player ) {
protected void applyAffect( Player player ) {
player . addPoints( alea . nextInt (40)+10);
player . receiveOneLife ( ) ;
}
}
}
}

public class OrangeSquare extends YellowSquare {

...
public int getNbPoints() {
return 2 ∗ super . getNbPoints ( ) ;
}

protected void applyEffect( Player player ) {

super . applyEffect ( player ) ;
super . applyEffect ( player ) ;
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 45
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests

tout code doit être testé

un code non testé n’a pas de valeur

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 46
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

pour rappel

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 47
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

Spécification :
l’effet appliqué par la conséquence d’une case jaune est que le joueur
gagne une vie
import static org . j u n i t . Assert . ∗ ;
import org . j u n i t . Test ;

public class YellowSquareTest {

@Test
public void consequenceAppliesEffectTest () {
YellowSquare yellow = new YellowSquare (1);
Player p = new Player ( Color .GREEN) ;
int l i v e s = p . getNbLives ( ) ;
yellow . consequence(p ) ;
assertEquals(1 , p . getNbLives () − l i v e s ) ;
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 48
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

indépendances des tests

Tester les méthodes setSquare et getSquare de Player.

Spécification :
Après l’exécution de la méthode setSquare, la méthode
getSquare doit fournir la case affectée.

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 49
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

indépendances des tests

Tester les méthodes setSquare et getSquare de Player.

Spécification :
Après l’exécution de la méthode setSquare, la méthode
getSquare doit fournir la case affectée.

quelle classe de Square pour le test ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 49
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

indépendances des tests

Tester les méthodes setSquare et getSquare de Player.

Spécification :
Après l’exécution de la méthode setSquare, la méthode
getSquare doit fournir la case affectée.

quelle classe de Square pour le test ?

utilisation de « Mock »

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 49
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests, héritage et classes abstraites

Comment tester les méthodes de Square ?

dans les tests de YellowSquare, BlueSquare, etc. ?
Pb : répétitions des codes des tests...
YellowSquare doit passer avec succès les tests de Square,
BlueSquare aussi... ainsi que les autres sous-classes de Square

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 50
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests, héritage et classes abstraites

Comment tester les méthodes de Square ?

dans les tests de YellowSquare, BlueSquare, etc. ?
Pb : répétitions des codes des tests...
YellowSquare doit passer avec succès les tests de Square,
BlueSquare aussi... ainsi que les autres sous-classes de Square
hiérarchie de classes de tests

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 50
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests, héritage et classes abstraites

Comment tester les méthodes de Square ?

dans les tests de YellowSquare, BlueSquare, etc. ?
Pb : répétitions des codes des tests...
YellowSquare doit passer avec succès les tests de Square,
BlueSquare aussi... ainsi que les autres sous-classes de Square
hiérarchie de classes de tests
YellowSquareTest hérite de SquareTest
YellowSquareTest en succès si passe ses propres tests + les tests
hérités de SquareTest
et similaire pour BlueSquareTest

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 50
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests, héritage et classes abstraites

Comment tester les méthodes de Square ?

dans les tests de YellowSquare, BlueSquare, etc. ?
Pb : répétitions des codes des tests...
YellowSquare doit passer avec succès les tests de Square,
BlueSquare aussi... ainsi que les autres sous-classes de Square
hiérarchie de classes de tests
YellowSquareTest hérite de SquareTest
YellowSquareTest en succès si passe ses propres tests + les tests
hérités de SquareTest
et similaire pour BlueSquareTest
comment gérer les instances ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 50
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests, héritage et classes abstraites

Comment tester les méthodes de Square ?

dans les tests de YellowSquare, BlueSquare, etc. ?
Pb : répétitions des codes des tests...
YellowSquare doit passer avec succès les tests de Square,
BlueSquare aussi... ainsi que les autres sous-classes de Square
hiérarchie de classes de tests
YellowSquareTest hérite de SquareTest
YellowSquareTest en succès si passe ses propres tests + les tests
hérités de SquareTest
et similaire pour BlueSquareTest
comment gérer les instances ?
méthode de fabrique (« factory method »)
+ initialisation attribut avec @Before
Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 50
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests méthodes abstraites

Comment tester consequence ? (effet appliqué et points ajoutés)

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 51
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests méthodes abstraites

Comment tester consequence ? (effet appliqué et points ajoutés)

utilisation de « Mock »

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 51
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

exceptions

removePlayer de Square lève une exception

UnknownPlayerException si le joueur à supprimer n’est pas sur la
case

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 52
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

création d’exception

package squaregame ;
public class UnknownPlayerException extends Exception {
public UnknownPlayerException( String msg) {
super(msg) ;
}
}

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 53
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

removePlayer

throws
throw new ...

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 54
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

capture (ou pas)

try ... catch

ou throws ...
RuntimeException ?

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 55
 fil rouge décomposer polymorphisme OCP late-binding factorisation tests exceptions

tests et exceptions

@Test(expected=UnkownPlayerException.class)

Université Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 56