Design pattern

1. UNIVERSITE D’ABOMEY-CALAVI
Institut des Mathematiques et des Sciences Physiques.
Design pattern
Bridge Pattern
Architecture Logicielle II
Présentateur:
Khalfan MBAZUMUTIMA
Enseignant:
CHARLY AGBOTON.
February 20, 2019

2. 1
Content
Définition
Définition
Intention
Problématique
Solutions
Constituants
Approche conventionnelle
Approche Bridge Pattern
Conséquence et Conclusion
Conséquence
Conclusion
@khalfan | Bridge Pattern

3. 2
Définition
Intention
Définition
Bridge Pattern (Pont) est un patron de conception qui permet de découpler
l’interface d’une classe et son implémentation,
IL appartient à la famille de Structural patterns.
Intention
Découpler une abstraction de son implémentation afin que les 2 éléments
puissent être modifiés indépendamment l’un de l’autre
@khalfan | Bridge Pattern

4. 3
Problématique
Problématique
Quand une abstraction peut avoir toute une série d’implémentations possibles,
le moyen usuel pour les fédérer est d’utiliser l’héritage :
une classe abstraite définit l’interface de l’abstraction
les sous-classes concrètes l’implémentent de différentes façons.
Cette approche n’est pas suffisamment souple :
l’héritage lie l’implémentation de façon permanente
ce qui rend difficile la modification, l’extension, la réutilisation des abstractions et
des implémentations indépendamment l’une de l’autre.
Ce couplage conduit à une explosion du nombre de classes.
@khalfan | Bridge Pattern

5. 4
Solutions
Solutions
Il faut donc découpler les abstractions des implémentations.
Le patron Pont traite ces problèmes en séparant l’abstraction et son
implémentation.
Définir une interface pour toutes les implémentations voulues et les faire
utiliser par les dérivations de la classe abstraite.
@khalfan | Bridge Pattern

6. 5
Constituants
Constituants
Abstraction: définit l’interface de l’abstraction ; gère une référence à un objet
de type Implementor.
Implementor: définit l’interface des classes d’implémentation. En général, elle
définit des opérations primitives.
bridge: lien d’association qui fait le pont entre l’abstraction et
l’implémentation.
Utilisation
Utiliser Bridge pattern lorsque:
on veut une liaison d’exécution de l’implémentation,
on veut partager une implémentation entre plusieurs objets,
@khalfan | Bridge Pattern

7. 6
Approche conventionnelle
Approche conventionnelle
Shape interface
Rectangle
red green
Square
red green
circle
red green
@khalfan | Bridge Pattern

8. 7
Diagramme des classes
Diagramme de classe
@khalfan | Bridge Pattern

9. 8
Approche Bridge Design
Approche Bridge Design
Shape interface color interface
Bridge class
Rectangle Squarecircle
red green
@khalfan | Bridge Pattern

10. 9
Diagramme des classes
Diagramme des classes
@khalfan | Bridge Pattern

11. 10
Coding
1 package bridge;
2
3 public abstract class Forme {
4
5 protected Color color;
6
7 public Forme(Color color) {
8 this.color = color;
9
10 }
11
12 public void fillColor () {
13
14 }
15
16 }
Forme.java
@khalfan | Bridge Pattern

12. 11
Coding
1 package bridge;
2
3 public class Cercle extends Forme {
4
5 public Cercle(Color color) {
6 super(color);
7 }
8
9 @Override
10 public void fillColor () {
11 System.out.print("Cercle de couleur");
12 color.fillColor ();
13 }
14
15 }
Cercle.java
@khalfan | Bridge Pattern

13. 12
Coding
1 package bridge;
2
3 public class Carre extends Forme {
4 public Carre(Color color) {
5 super(color);
6 }
7
8 @Override
9 public void fillColor () {
10 System.out.print("Carré de couleur ");
11 color.fillColor ();
12 }
13
14 }
Carre.java
@khalfan | Bridge Pattern

14. 13
Coding
1 package bridge;
2
3 public interface Color {
4
5 void fillColor ();
6 }
Color.java
@khalfan | Bridge Pattern

15. 14
Coding
1 package bridge;
2
3 public class Vert implements Color {
4
5 public void fillColor () {
6
7 System.out.println("Vert");
8 }
9
10 }
Vert.java
@khalfan | Bridge Pattern

16. 15
Coding
1 package bridge;
2
3 public class Blue implements Color {
4
5 public void fillColor () {
6
7 System.out.println("Bleu");
8 }
9
10 }
Blue.java
@khalfan | Bridge Pattern

17. 16
Coding
1 package bridge;
2
3 public class TestBridge {
4
5 public static void main(String [] args) {
6 Forme carre = new Carre(new Blue());
7 carre.fillColor ();
8
9 // Forme cercle = new Cercle(new Blue());
10 // cercle.fillColor ();
11
12 Forme cercle = new Cercle(new Vert());
13 cercle.fillColor ();
14
15 }
16
17 }
TestBridge.java@khalfan | Bridge Pattern

18. 17
Conséquence et Conclusion
Conséquence
Le découplage des implémentations à partir des objets les utilisant accroît les
possibilités d’extension.
Les clients ignorent les problèmes d’implémentation.
Conclusion
À la création de l’abstraction, il faut lier l’instance à une instance de
l’implémentation.
L’abstraction transmet les requêtes client à l’objet implémentation qui lui est
lié.
@khalfan | Bridge Pattern

19. Thank you !