Design patterns - p.

1
Design patterns
Design patterns - p. 2
Dfinition
Les design patterns ou modles de
conception dcrivent des organisations
pratiques de classes dobjets.
Forme d'organisation transposable
plusieurs applications.
viter dtre satur par la complexit du
codage (effet spaghetti).
Design patterns - p. 3
Catgories
Trois grandes catgories
Les modles de cration : Ces modles sont trs
courants pour dsigner une classe charge de
construire des objets.
Les modles de structure : Ces modles tendent
concevoir des agglomrations de classes avec des
macro-composants.
Les modles de comportement : Ces modles tentent
de rpartir les responsabilits entre chaque classe.
Design patterns - p. 4
Modles de cration
Fabrique de cration
Une fabrique de cration (ou factory) est une
classe qui n'a pour rle que de construire des
objets.
Cette classe utilise des interfaces ou des
classes abstraites pour masquer l'origine des
objets.
Design patterns - p. 5
Fabrique de cration
Utile lorsque :
Les crations entranent des duplications du
code au dtriment de la rutilisation
Lobjet compos na pas besoin de connatre
les informations ou ressources utiles la
cration
La gestion de la dure de vie des objets doit
tre centralise
Design patterns - p. 6
Fabrique de cration
/** Interface de description d'un point */
public interface Point {
/** Retourne l'abscisse du point */
public int getX();
/** Retourne l'ordonne du point */
public int getY();
}
public interface Line { ... }
/** Fabrique retournant des objets de types point ou ligne */
public class CanvasFactory {
/** Retourne un Point aux coordonnes x,y */
public Point getPoint( int x, int y ) {
return new PointImpl( x, y );
}
/** Retourne une Ligne aux coordonnes x1,y1,x2,y2 */
public Line getLine( int x1, int y1, int x2, int y2 ) {
return new LineImpl( x1, y1, x2, y2 );
}
}
Exemple
Cette classe
masque la
vritable
Nature
des objets.
Design patterns - p. 7
Fabrique abstraite
Elle retourne un pointeur abstrait sur un
objet concret
Le client na pas connatre le type concret
Seulement lutiliser via linterface
abstraite
La fabrique permet de localiser lendroit du
code o les objets sont construits
Singleton
Design patterns - p. 8
Fabrique abstraite
Exemple
masque la
vritable
Nature
des objets.
Design patterns - p. 9
Modles de cration
Modle Singleton
Ce modle sutilise lorsque il ny a quune unique
instance dune classe et quelle doit tre accessible
de manire connue.
Design patterns - p. 10
Modles Singleton
Modle Singleton
Le modle garantit lunicit de lobjet cr
et linterdiction dinstanciations multiples
class Singleton {
private static Singleton unique = new Singleton();
private Singleton() {}
Public static Singleton getInstance() {
return unique;
}
}
Design patterns - p. 11
Modles de cration
Builder
Le Builder ou Monteur est une classe offrant
des moyens de construction d'un objet.
Dfinit comment seffectue la cration.
Excuter les tapes de la cration.
Design patterns - p. 12
Builder
Design patterns - p. 13
Builder
/** "Product" */
class Pizza {
private String dough = "";
private String sauce = "";
private String topping = "";
public void setDough(String dough) {
this.dough = dough;
}
public void setSauce(String sauce) {
this.sauce = sauce;
}
public void setTopping(String topping) {
this.topping = topping;
}
}
Design patterns - p. 14
Builder
/** "Abstract Builder" */
abstract class PizzaBuilder {
protected Pizza pizza;
public Pizza getPizza() {
return pizza;
}
public void createNewPizzaProduct()
{
pizza = new Pizza();
}
public abstract void buildDough();
public abstract void buildSauce();
public abstract void buildTopping();
}
Design patterns - p. 15
Builder
/** "ConcreteBuilder" */
class HawaiianPizzaBuilder extends PizzaBuilder {
public void buildDough() {
pizza.setDough("cross");
}
public void buildSauce() {
pizza.setSauce("mild");
}
public void buildTopping() {
pizza.setTopping("ham+pineapple");
}
}
/** "ConcreteBuilder" */
class SpicyPizzaBuilder extends PizzaBuilder {
public void buildDough() {
pizza.setDough("pan baked");
}
public void buildSauce() {
pizza.setSauce("hot");
}
public void buildTopping() {
pizza.setTopping("pepperoni+salami");
}
}
Design patterns - p. 16
Builder
/** "Director" */
class Cook {
private PizzaBuilder pizzaBuilder;
public void setPizzaBuilder(PizzaBuilder pb) {
pizzaBuilder = pb;
}
public Pizza getPizza() {
return pizzaBuilder.getPizza();
}
public void constructPizza() {
pizzaBuilder.createNewPizzaProduct();
pizzaBuilder.buildDough();
pizzaBuilder.buildSauce();
pizzaBuilder.buildTopping();
}
}
Design patterns - p. 17
Builder
/** A given type of pizza being constructed. */
public class BuilderExample {
public static void main(String[] args) {
Cook cook = new Cook();
PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();
cook.setPizzaBuilder(hawaiianPizzaBuilder);
cook.constructPizza();
Pizza pizza = cook.getPizza();
}
}
Design patterns - p. 18
Modles de structure
Ces modles de conception tentent de
composer des classes pour btir de
nouvelles structures.
Les objets ainsi conus forment un nouvel
objet que l'on peut dplacer, et manipuler
sans avoir rpter ces oprations sur
chaque objet qui le compose.
Design patterns - p. 19
Adapter
Adapter (wrapper pattern)
Faire fonctionner un objet avec une interface
qu'il ne possde pas.
Classe supplmentaire qui se charge
d'implmenter la bonne interface (L'Adapteur)
et d'appeler les mthodes correspondantes
dans l'objet utiliser (L'adapt).
Design patterns - p. 20
Adapter
Design patterns - p. 21
Adapter
Exemple
/** Interface de reprsentation d'un cercle */
public interface Circle {
public int getX();
public int getY();
public int getR();
}
/** Classe implmentant l'interface Circle */
public class CircleImpl implements Circle {
...
}
/** Adapteur pour transformer le circle en un point */
public class CircleImplPointAdapter implements Point {
private Circle c;
public CircleImplPointAdapter( Circle c ) {
this.c = c;
}
public int getX() { return c.getX(); }
public int getY() { return c.getY(); }
}
Design patterns - p. 22
Bridge
Bridge
viter un lien permanent entre l'abstraction et
l'implantation (ex: l'implantation est choisie
l'excution).
Abstraction et implantation sont toutes les
deux susceptibles d'tre raffines.
Les modifications subies par l'implantation ou
l'abstraction ne doivent pas avoir d'impacts sur
le client (pas de recompilation).
Design patterns - p. 23
Bridge
Design patterns - p. 24
Bridge
/** "Implementor" */
interface DrawingAPI {
public void drawCircle(double x, double y, double radius);
}
/** "ConcreteImplementor" 1/2 */
class DrawingAPI1 implements DrawingAPI {
public void drawCircle(double x, double y, double radius) {
System.out.printf(
"API1.circle at %f:%f radius %f\n",
x, y, radius);
}
}
/** "ConcreteImplementor" 2/2 */
class DrawingAPI2 implements DrawingAPI {
public void drawCircle(double x, double y, double radius) {
System.out.printf(
"API2.circle at %f:%f radius %f\n",
x, y, radius);
}
}
Exemple
Design patterns - p. 25
Bridge
/** "Abstraction" */
interface Shape {
public void draw();// low-level
public void resizeByPercentage(double pct);// high-level
}
/** "Refined Abstraction" */
class CircleShape implements Shape {
private double x, y, radius;
private DrawingAPI drawingAPI;
public CircleShape(
double x, double y, double radius,
DrawingAPI drawingAPI) {
this.x = x;
this.y = y;
this.radius = radius;
this.drawingAPI = drawingAPI;
}
/** low-level i.e. Implementation specific */
public void draw() { drawingAPI.drawCircle(x, y, radius); }
/** high-level i.e. Abstraction specific */
public void resizeByPercentage(double pct) { radius *= pct; }
}
Exemple
Design patterns - p. 26
Bridge
Exemple
/** "Client" */
class BridgePattern {
public static void main(String[] args) {
Shape[] shapes = new Shape[2];
shapes[0] = new CircleShape(1, 2, 3, new DrawingAPI1());
shapes[1] = new CircleShape(5, 7, 11, new DrawingAPI2());
for (Shape shape : shapes) {
shape.resizeByPercentage(2.5);
shape.draw();
}
}
}
Design patterns - p. 27
Proxy
Proxy et decorator
Ajouter un niveau de redirection entre l'appel
d'une mthode d'un objet et l'action associe.
Une nouvelle classe implmente l'interface de
l'objet manipuler et dporte toutes les actions
sur un autre objet implmentant la mme
interface.
Changer l'objet cible sans changer l'objet
source (manipul).
Design patterns - p. 28
Proxy
Design patterns - p. 29
Proxy
Exemple
/** Interface reprsentant un espace de dessin */
public interface Canvas {
/** Ajout d'un objet graphique */
public void addGraphicElement( GraphicElement ge );
}
/** Proxy pour l'espace de dessin */
public class CanvasProxy implements Canvas {
private Canvas c;
public CanvasProxy( Canvas c ) {
this.c = c;
}
public void addGraphicElement( GraphicElement ge ) {
c.addGraphicElement( ge );
}
}
Design patterns - p. 30
Decorator
Exemple : la classe BufferedReader() de
lAPI Java
BufferedReader in = new
BufferedReader(new FileReader("file.txt"));
Design patterns - p. 31
Composite
Composite
Composition rcursive dobjets.
Reprsenter une hirarchie d'objets.
Ignorer la diffrence entre un composant
simple et un composant en contenant d'autres
(interface uniforme).
Exemple du groupe d'objets dans un logiciel
de dessin.
Design patterns - p. 32
Composite
Design patterns - p. 33
Composite
/** Composant */
public interface Graphic {
public void print();
}
/** Composite */
public class CompositeGraphic implements Graphic {
private List<Graphic> mChildGraphics = new ArrayList<Graphic>();
public void print() {
for (Graphic graphic : mChildGraphics) {
graphic.print();
}
}
/** Ajout d'un objet graphique */
public void add( Graphic ge );
}
/** Feuille */
public class Ellipse implements Graphic {
public void print() { System.out.println("Ellipse"); }
}
Design patterns - p. 34
Modles de comportement
Ils dcrivent la manire dont les objets
interagissent entre eux.
Iterator
Observer
Visitor
Design patterns - p. 35
Iterator
Accder aux lments dun objet sans en
exposer la structure.
Offrir une interface uniforme pour parcourir
diffrents types dobjets.
Implment dans lAPI java via linterface
java.util.Iterator
Design patterns - p. 36
Iterator
Design patterns - p. 37
Observer
Lorsquon souhaite que le changement
dun objet affecte dautres objets.
Que cet objet ne connaisse pas a priori les
objets notifier.
Implment dans lAPI java via la classe
java.util.Observable et linterface
java.util.Observer.
Design patterns - p. 38
Observer
Design patterns - p. 39
Visitor
Permet de parcourir une structure.
Pour y appliquer des oprations dfinies
indpendamment de la structure.
Applique des oprations qui dpendent la
fois des lments de la structure et du type
dimplantation des oprations.
Technique du double dispatch .
Design patterns - p. 40
Visitor

[0,N]
CVisiteur
VisiteElementConcretA(unElementConcretA)=0
VisiteElementConcretB(unElementConcretB)=0
CVisiteurConcret1
VisiteElementConcretA(unElementConcretA)
VisiteElementConcretB(unElementConcretB)
CVisiteurConcret2
VisiteElementConcretA(unElementConcretA)
VisiteElementConcretB(unElementConcretB)
CElement
Accept(CVisiteur v)
CElementConcretA
Accept(CVisiteur v) {
v-> VisiteElementConcretA(this) ; }
CElementConcretB
Accept(CVisiteur v) {
v-> VisiteElementConcretB(this) ; }
CElementCollection
Visite(CVisiteur v){
Pour chaque lment appelle Accept(v);}


Client
Design patterns - p. 41
Visitor

unCElementCollection unCElementConcretA unCElementConcretB unCVisiteurConcret
Temps
Effectue lopration
VisiteElementConcretA(unElementConcretA)
Accept(unVisiteurConcret)
Effectue lopration
VisiteElementConcretB(unElementConcretB)
Accept(unVisiteurConcret)
Design patterns - p. 42
Visitor
Lajout dune opration sur les lments est
trs facile puisquil suffit dajouter une
classe drive de CVisiteur.
Les oprations similaires sur des
CElement diffrents sont runies, et les
oprations diffrentes sont spares, par
architecture.
Les classe CElementConcret ne sont
pas surcharges par des oprations.
Design patterns - p. 43
Visitor
Technique du Double dispatch :
Le polymorphisme sapplique sur deux types.
Dabord le polymorphisme sapplique dans la mthode
CElementCollection::Accept() sur les
classes drives de CElement.
Ensuite le polymorphisme sapplique dans la mthode
CElementConcret::VisiteElementConcret
() sur les classes drives de CVisiteur.
Design patterns - p. 44
Visitor