-
Rappels et Introduction
Conception Orientée Objet
Clément Quinton1
Licence mention Informatique
Université de Lille
1Largement inspiré par Jean-Christophe Routier
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Présentation
Prolongement immédiat de l’UE POO du S4 informatique
http://portail.fil.univ-lille1.fr/portail/ls3/poo
Après la programmation... la conception
Objectif: construire des logiciels en utilisant des concepts objets
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 2
http://portail.fil.univ-lille1.fr/portail/ls3/poo
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Fonctionnement
Equipe pédagogique
Bilel Derbel, Xavier Le Pallec, Jérémy Lictevout, Damien Pollet,
Clément Quinton, Jean-François Roos, Jean-Christophe Routier,
Valentin Owczarek
1h30 de cours (6 séances). 1h30 TD/1h30 TP une semaine sur deux
Préparer les TD chez vous avant la séance!
Evaluation continue :
Un projet unique avec plusieurs livraisons
Un DS
Note UE: moy(moy(livraisons projet), DS)
http://portail.fil.univ-lille1.fr/portail/ls5/coo
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 3
http://portail.fil.univ-lille1.fr/portail/ls5/coo
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Fonctionnement - BCC
Bloc de Connaissances et de Compétences
Conception Orientée Objet (3 ECTS)
Programmation Fonctionnelle (6 ECTS)
Bases De Données (3 ECTS)
Compensation entre UEs d’un même BCC.
Tous les BCC doivent être validés.
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 4
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
A l’issue de ce module vous devr(i)ez...
Mâıtriser les concepts de la programmation objet :
Mâıtriser les di�érentes manières de mettre en œuvre le polymorphisme ;
Connâıtre quelques principes de conception objet et savoir les mettre en
œuvre ;
Savoir 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 ;
Connâı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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 5
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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, Iterator, IterableList/ArrayList/LinkedList, Set,
Map/HashMap, hashCode
package, import
javac, java, jar, javadoc, classpath, tests (JUnit)
Òæ “Le TP4” de POO à (re)faire (voir semainier)Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 7
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 8
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Contenu du cours
1. Rappels; Premiers éléments de conception; Outillage
2. Test-Driven Development; Mutation Testing
3. Génériques
4. Principes de conception (1/2)
5. Principes de conception (2/2)
6. Design patterns
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 9
-
Conception...
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Un jeu de plateau simple :
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 11
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Un jeu de plateau simple :
Une piste constituée de cases de di�érentes couleurs ;
Les joueurs sont représentés chacun par un pion de couleur di�érente,
é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, il marque des points en
conséquence et la case produit un e�et. 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’e�et 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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 12
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Game
- players : List- allSquares : Square[]
- currentPlayer : Player
+ Game()
+ addPlayer(p: Player)
+ play()
...
Player
- currentSquare : Square
- nbPoints :int
- nbLives : int
- color : Color
+ Player(c: Color)
+ getSquare() : Square
+ setSquare(s : Square)
+ getPoints() : int
+ getColor() : Color
+ getNbLives() : int
+ addPoints(pts : int)
+ receiveOnLife()
+ loseOneLife()
...
Square
- index : int
- players : List- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 13
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Game
- players : List- allSquares : Square[]
- currentPlayer : Player
+ Game()
+ addPlayer(p: Player)
+ play()
...
Player
- currentSquare : Square
- nbPoints :int
- nbLives : int
- color : Color
+ Player(c: Color)
+ getSquare() : Square
+ setSquare(s : Square)
+ getPoints() : int
+ getColor() : Color
+ getNbLives() : int
+ addPoints(pts : int)
+ receiveOnLife()
+ loseOneLife()
...
Square
- index : int
- players : List- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 13
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Dans la classe Game :
/⇤⇤ . . . ⇤/public void play() {
Iterator playerIt = this . players . i terator () ;boolean f inished = false ;
while (! f inished ) {i f (! playerIt . hasNext()) {
playerIt = this . players . i terator () ;
}this . currentPlayer = playerIt . 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 ) ;
}f inished = this . currentPlayer . getNbPoints() > 1000 || this . players . s ize () == 1;
}Player winner ;
i f ( this . players . s ize () == 1) {winner = this . players . get (0);
} else {winner = this . currentPlayer ;
}System. out . pr int ln ("the winner is " + winner ) ;
}
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 14
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Euh...
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 15
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Euh...
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 16
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Décomposer
Il faut
dé - com - po - ser
Principe de Responsabilité Unique
Une méthode, une fonctionnalité
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 17
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
public void play () {Iterator playerIt = this . players . i terator () ;boolean f inished = false ;
while (! f inished ) {// compute next player
i f (! playerIt . hasNext()) {playerIt = this . players . i terator ()
}this . currentPlayer = playerIt . 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 ) ;
}f inished = this . currentPlayer . getNbPoints() > 1000 || this . players . s ize () == 1;
}// who i s the winner ?
Player winner ;
i f ( this . players . s ize () == 1) {winner = this . players . get (0);
} else {winner = this . currentPlayer ;
}System. out . pr int ln ("the winner is " + winner ) ;
}Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 18
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
public void play () {Iterator playerIt = this . players . i terator () ;boolean f inished = false ;
while (! f inished ) {// compute next player
i f (! playerIt . hasNext()) {playerIt = this . players . i terator ()
}this . currentPlayer = playerIt . 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 ) ;
}f inished = this . currentPlayer . getNbPoints() > Game.WINNING POINTS || this . players . s ize () == 1;
}// who i s the winner ?
Player winner ;
i f ( this . players . s ize () == 1) {winner = this . players . get (0);
} else {winner = this . currentPlayer ;
}System. out . pr int ln ("the winner is " + winner ) ;
}Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 19
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
public void play () {
while (! f inished ) {// 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 ???
finished =
}// who i s the winner ?
}Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 20
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é pour play() :gérer la « boucle principale » du jeu
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 21
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
avec :
protected boolean isFinished () { responsabilité : déterminer si le jeu est finii f ( this . currentPlayer . getNbLives() < 0) {
this . players . remove( this . currentPlayer ) ;
}return this . currentPlayer . getNbPoints() > WINNING POINTS || this . players . s ize () == 1;
}
protected Player nextPlayer () { . . . } responsabilité : choisir le prochain joueur
protected Square computeNextSquare() { responsabilité : calculer nouvelle case du joueurint dice = this . currentPlayer . throwDice () ;
int currentSquareIndex = this . currentPlayer . getSquare () . getIndex () ;
return this . allSquares [ currentSquareIndex+dice ] ;
}
protected void moveCurrentPlayer(Square nextSquare) { responsabilité : déplacer le joueurthis . currentPlayer . getSquare () . removePlayer( this . currentPlayer ) ;
this . currentPlayer . setSquare(nextSquare ) ;
nextSquare . addPlayer( this . currentPlayer ) ;
}
public void displayWinner () { responsabilité : a�cher le vainqueurPlayer winner ;
i f ( this . players . s ize () == 1) {winner = this . players . get (0);
} else {winner = this . currentPlayer ;
}System. out . pr int ln ("the winner is " + winner ) ;
}
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 22
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 23
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Méthode consequence
lorsqu’un joueur s’arrête sur une case, la conséquence est qu’il marquedes points et la case produit un e�et. Les points marqués sont doubléssi la couleur du joueur est la même que celle de la case. Le nombre depoints marqués et l’e�et varient en fonction de la couleur de la case.Certaines cases font marquer plus de points, d’autre perdre des vies,etc.
Par exemple, si la couleur de la case est :
bleue, le joueur marque 100 points et reçoit un bonus entre 10 et 50points
jaune, le joueur marque 50 points et gagne une vieorange, la conséquence est le double de celle d’une case jaunerouge, le joueur marque -100 points et perd une vie
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 24
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
nextSquare.consequence(this.currentPlayer);
consequence doit (« contrat »)
ajouter au joueur le nombre de points correspondant à la case (points
doublés si les couleurs correspondent)
a�cher le nombre de points gagnés
appliquer l’e�et correspondant à la couleur de la case
indiquer si le joueur a perdu toutes ses vies
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 25
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Dans Square :
/⇤⇤ add points to the player and apply square effect . Points and effect depend⇤ on square color . Won points are displayed and player i s noti f ied i f ( s )he has⇤ lost a l l i t s l i v e s .⇤ @param player the player reaching this square⇤/
public void consequence(Player player ) {// points management
int points = this . getNbPoints () ;
i f (player . getColor () . equals ( this . color )) { // double points i f same colorpoints = 2 ⇤ points ;
}player . addPoints(points ) ;
System. out . pr int ln (player+" gets "+points ) ;
// apply the square effect
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 lost a l l i t s l i v e s ?
i f (player . getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Evolution: si la case est noire, le joueur perd 2 vies
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 27
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Evolution: si la case est noire, le joueur perd 2 vies
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 27
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 28
Plusieurs comportements ∆ plusieurs types
polymorphisme + late-binding
Di�érents types de Square
Square
- index : int
- players : List- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Squares
Di�érents types de cases :
di�é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)
di�èrent sur les comportements de consequence
pas de « comportement par défaut »
classe abstraite + héritage
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 29
Square
- index : int
- players : List- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Squares
Di�érents types de cases :
di�é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)
di�èrent sur les comportements de consequence
pas de « comportement par défaut »
classe abstraite + héritage
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 29
Square
- index : int
- players : List- color : Color
+ Square(idx :int, c : Color)
+ getIndex() : int
+ getColor() : Color
+ addPlayer(p : Player)
+ removePlayer(p : Player)
+ consequence(p : Player)
...
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 30
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
public class YellowSquare extends Square {private static f ina l int YELLOW POINTS = 50;
public YellowSquare( int index) {super( index , Color .YELLOW);
}
public void consequence(Player player ) {// points management
int points = YELLOW POINTS;
i f (player . getColor () == this . color ) {points = 2 ⇤ points ;
}player . addPoints(points ) ;
System. out . pr int ln (player+" gets "+points ) ;
// apply the square effect
player . receiveOneLife () ;
// has the player lost a l l i t s l i v e s ?
i f (player . getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Si la couleur de la case est :orange, la conséquence est le double de celle d’une case jaune
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 32
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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 {private static f ina l int YELLOW POINTS = 50;
public YellowSquare( int index) {super( index , Color .YELLOW);
}
public void consequence(Player player ) {// points management
int points = YELLOW POINTS;
i f (player . getColor () == this . color ) {points = 2 ⇤ points ;
}player . addPoints(points ) ;
System. out . pr int ln (player+" gets "+points ) ;
// apply the square effect
player . receiveOneLife () ;
// has the player lost a l l i t s l i v e s ?
i f (player . getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
« Et si le code de YellowSquare évolue? »
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 35
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Si la couleur de la case est :orange, la conséquence est le double de celle d’une case jaune
Utiliser super
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 36
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 37
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Evolution
Ajout d’une nouvelle couleur. Si la case est noire, le joueur perd deux vies.
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 38
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 39
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 40
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 41
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 41
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 41
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 42
public static void main(String [ ] args) {List l i steA = new ArrayList();l isteA .add(new B()) ;
l isteA .add(new C()) ;
for (A a : l isteA ) {System. out . pr int ln ("- appel h() -") ;a .h() ;
System. out . pr int ln ("- appel f() -") ;a . f () ;
}}
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 43
public static void main(String [ ] args) {List l i steA = new ArrayList();l isteA .add(new B()) ;
l isteA .add(new C()) ;
for (A a : l isteA ) {System. out . pr int ln ("- appel h() -") ;a .h() ;
System. out . pr int ln ("- appel f() -") ;a . f () ;
}} ≠ appel h() ≠
A.h
B.k
≠ appel f () ≠B. f
A. f
A. z
B.k
A.g
A.g
≠ appel h() ≠C.h
A.m
≠ appel de f () ≠B. f
A. f
A. z
B.k
C.g
C.g
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 44
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Lookup avec super
super est une référence vers l’objet qui reçoit le message (“invoquant”)
super == this
Mais la recherche de méthode (lookup) avec super est di�érente :Méthode publique :
la recherche commence dans la super-classe de la classe définissant
la méthode utilisant super
le processus de châı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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 45
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Factorisation de code
public abstract class Square {. . .
public abstract void consequence(Player player ) ;
}
public class YellowSquare extends Square {. . .
public void consequence(Player player ) {// points management
int points = 50;
i f (player . getColor () . equals ( this . color )) {points = 2 ⇤ points ;
}player . addPoints(points ) ;
System. out . pr int ln (player+" gets "+points ) ;
// apply the square effect
player . receiveOneLife () ;
// has the player lost a l l i t s l i v e s ?
i f (player . getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Dans le contrat de consequence
ajouter au joueur le nombre points correspondant à la case(points doublés si les couleurs correspondent)a�cher le nombre de points gagnésappliquer l’e�et correspondant à la couleur de la caseindiquer si le joueur a perdu toutes ses vies
Seuls le nombre de points et l’application de l’e�et 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é de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 47
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Il faut séparer ce qui change de ce qui ne varie pas
Dans...
public void consequence(Player player) {// points managementint points = 100;if (player.getColor().equals(this.color)) {
points = 2 * points;}player.addPoints(points);System.out.println(player+" gets "+points);// apply the square effectplayer.addPoints(alea.nextInt(40)+10);;// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Il faut séparer ce qui change de ce qui ne varie pas
Dans... BlueSquare
public void consequence(Player player) {// points managementint points = 100;if (player.getColor().equals(this.color)) {
points = 2 * points;}player.addPoints(points);System.out.println(player+" gets "+points);// apply the square effectplayer.addPoints(alea.nextInt(40)+10);;// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Il faut séparer ce qui change de ce qui ne varie pas
Dans... YellowSquare
public void consequence(Player player) {// points managementint points = 50;if (player.getColor().equals(this.color)) {
points = 2 * points;}player.addPoints(points);System.out.println(player+" gets "+points);// apply the square effectplayer.receiveOneLife();// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Il faut séparer ce qui change de ce qui ne varie pas
Dans... tous les Square
public void consequence(Player player) {// points managementint 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()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Il faut séparer ce qui change de ce qui ne varie pas
Dans... tous les Square
public void consequence(Player player) {// points managementint points = this.getNbPoints();if (player.getColor().equals(this.color)) {
points = 2 * points;}player.addPoints(points);System.out.println(player+" gets "+points);// apply the square effectthis.applyEffect(player);// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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 effectthis.applyEffect(player);
// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
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 effectthis.applyEffect(player);
// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
Utiliser les « outils » à disposition pour consolider le contrat
public abstract class Square {...public final void consequence(Player player) {
// points managementint points = this.getNbPoints();if (player.getColor().equals(this.color)) {
points = 2 * points;}player.addPoints(points);System.out.println(player+" gets "+points);
// apply the square effectthis.applyEffect(player);
// has the player lost all its lives ?if (player.getNbLives()
-
Intro Fil rouge Décomposer Polymorphisme OCP Late-binding Factorisation
public class YellowSquare extends Square {. . .
public int getNbPoints() {return 50;
}
protected void applyA�ect(Player player ) {player . receiveOneLife () ;
}}
public class BlueSquare extends Square {. . .
public int getNbPoints() {return 100;
}
protected void applyE�ect(Player player ) {player . addPoints(alea . nextInt(40)+10);
}}
public class OrangeSquare extends YellowSquare {. . .
public int getNbPoints() {return 2 ⇤ super . getNbPoints () ;
}
protected void applyE�ect(Player player ) {super . applyEffect (player ) ;
super . applyEffect (player ) ;
}}
Université de Lille – Sciences et Technologies - Licence mention Informatique Conception Orientée Objet 50
Introprésentation
Fil rougefil rouge
Décomposergod method
Polymorphismeconsequence
OCPOCP
Late-bindinglate-bindingLookup
Factorisationfactorisation