Quand j'ai commencé à apprendre Java, lorsque le professeur parlait d'héritage, il aimait toujours utiliser un exemple pour l'expliquer, et c'était le dessin. Ici, nous avons un pinceau qui peut dessiner des carrés, des rectangles et des cercles (tout le monde sait comment faire, donc je ne vais pas l'expliquer). Mais maintenant, nous devons colorer ces formes, et il y a trois couleurs : blanc, gris et noir. Ici, nous pouvons dessiner 3*3=9 formes : carrés blancs, rectangles blancs, cercles blancs... À ce stade, nous savons presque qu'il y a deux solutions :

  • Solution 1 : fournir plusieurs versions de couleur pour chaque forme.
  • Solution 2 : combiner les couleurs et les formes selon les besoins réels.

Si nous utilisons la Solution 1 pour l'implémenter, pouvons-nous aussi le comprendre ainsi ? Fournir plusieurs versions de forme pour chaque couleur ? C'est tout à fait possible. Comme suit :

Pour les deux formes de la Solution 1, nous comprenons tous clairement ce problème : si nous ajoutons une ellipse, devons-nous ajouter trois couleurs de plus ? Si nous ajoutons une couleur verte, nous devons ajouter quatre formes de plus. Continuez d'ajouter. Continuez d'ajouter... Chaque ajout augmentera un certain nombre de classes (si une couleur est ajoutée, des classes égales au nombre de formes sont ajoutées ; si une forme est ajoutée, des classes égales au nombre de couleurs sont ajoutées). Je pense qu'aucun programmeur ne voudrait cela ! Alors regardons la Solution 2. La solution fournie par la Solution 2 est : fournir deux classes parentes, une pour la couleur et une pour la forme. La classe parente de couleur et la classe parente de forme contiennent toutes deux les sous-classes correspondantes, puis combinez les couleurs et les formes selon les besoins.

Pour les situations comportant plusieurs dimensions changeantes, nous utilisons généralement la Solution 2 pour implémenter. En plus de réduire le nombre de classes dans le système, elle facilite également l'extension du système. L'application de la Solution 2 est appelée le patron de conception Pont.

1. Définition du patron

Le patron Pont sépare l'abstraction de son implémentation afin qu'elles puissent toutes deux changer indépendamment.

Le patron Pont convertit les relations d'héritage en relations d'association. Il réduit le couplage entre les classes, réduit le nombre de classes dans le système et réduit la quantité de code.

La phrase "séparer l'abstraction de son implémentation" n'est pas facile à comprendre. En fait, il ne s'agit pas de séparer une classe abstraite de ses classes dérivées, mais plutôt que la classe abstraite et ses classes dérivées utilisent leurs propres objets pour implémenter. Si vous ne comprenez toujours pas, commençons par comprendre ce que sont l'abstraction, l'implémentation et le découplage.

Abstraction :Son concept est l'action ou le processus d'extraire une ou plusieurs caractéristiques d'un objet complexe tout en ne prêtant attention qu'à d'autres caractéristiques. En programmation orientée objet, c'est le processus d'extraction des propriétés communes des objets pour former une classe.

Implémentation :La mise en œuvre concrète donnée pour l'abstraction. C'est un processus inverse de l'abstraction ; l'implémentation est une concrétisation plus poussée des choses abstraites.

Découplage :Le découplage consiste à libérer le couplage entre l'abstraction et l'implémentation, ou à transformer la relation forte entre elles en une relation faible, et à changer la relation d'héritage entre les deux rôles en une relation d'association.

Quant à cette phrase : "séparer l'abstraction de son implémentation", en l'appliquant dans *Big Talk Design Patterns*, cela signifie que le système d'implémentation peut avoir plusieurs angles de classification, et que chaque angle peut changer. Séparez ensuite ces classifications multi-angles afin qu'elles changent indépendamment, réduisant ainsi le couplage entre elles.

Le soi-disant découplage dans le patron Pont signifie utiliser une relation d'association (relation de composition ou d'agrégation) entre l'abstraction et l'implémentation dans un système logiciel au lieu d'une relation d'héritage, afin que les deux puissent changer de manière relativement indépendante. C'est l'intention du patron Pont.

2. Structure du patron

     

La figure suivante présente le diagramme de structure UML du patron Pont :

Le patron Pont comprend principalement les rôles suivants :

  • Abstraction: classe abstraite.
  • RefinedAbstraction: abstraction raffinée.
  • Implementor: interface Implementor.
  • ConcreteImplementor: implémenteur concret.

3. Implémentation du patron

Pour le scénario du patron, nous utilisons l’exemple de dessin. Son diagramme de structure UML est le suivant :

Tout d’abord, la classe Shape : cette classe est une classe abstraite qui fournit principalement une méthode pour dessiner des formes. Shape.java :

Exemple

public abstract class Shape { Color color; public void setColor(Color color) { this.color = color; } public abstract void draw(); }

Puis les trois formes.

Circle (Circle.java):

Exemple

public class Circle extends Shape{ public void draw() { color.bepaint("Square"); } }

Rectangle (Rectangle.java):

Exemple

public class Rectangle extends Shape{ public void draw() { color.bepaint("Rectangle"); } }

Square (Square.java):

Exemple

public class Square extends Shape{ public void draw() { color.bepaint("Square"); } }

Interface Color (Color.java):

Exemple

public interface Color { public void bepaint(String shape); }

White (White.java):

Exemple

public class White implements Color{ public void bepaint(String shape) { System.out.println("White" + shape); } }

Gray (Gray.java):

Exemple

public class Gray implements Color{ public void bepaint(String shape) { System.out.println("Gray" + shape); } }

Black (Black.java):

Exemple

public class Black implements Color{ public void bepaint(String shape) { System.out.println("Black" + shape); } }

Client (Client.java):

Exemple

public class Client { public static void main(String[] args) { //White Color white = new White(); //Square Shape square = new Square(); //White square square.setColor(white); square.draw(); //Rectangle Shape rectange = new Rectangle(); rectange.setColor(white); rectange.draw(); } }

Sortie :

white square
white rectangle

4. Avantages et inconvénients du patron

Avantages

  • 1. Séparer l'interface abstraite et son implémentation. Cela fournit une meilleure solution que l'héritage.
  • 2. Le patron Bridge améliore l'extensibilité du système. Étendre l'une ou l'autre des deux dimensions variables ne nécessite pas de modifier le système d'origine.
  • 3. Les détails d'implémentation sont transparents pour les clients, et les détails d'implémentation peuvent être cachés aux utilisateurs.

Inconvénients

    
  • 1. L'introduction du patron Bridge augmente la difficulté de compréhension et de conception du système. Parce que la relation d'agrégation/d'association est établie au niveau de la couche d'abstraction, les développeurs doivent concevoir et programmer pour des abstractions.
  • 2. Le patron Bridge exige d'identifier correctement deux dimensions qui changent indépendamment dans le système, de sorte que son domaine d'utilisation présente certaines limites.

5. Scénarios d'utilisation

    
  • 1. Si un système doit ajouter plus de flexibilité entre le rôle d'abstraction et le rôle d'implémentation de ses composants, et éviter d'établir un lien d'héritage statique entre les deux niveaux, le modèle Pont peut établir une relation d'association entre eux au niveau de la couche d'abstraction.
  • 2. Le modèle Pont est particulièrement applicable aux systèmes qui ne souhaitent pas utiliser l'héritage, ou lorsque l'héritage à plusieurs niveaux entraîne une forte augmentation du nombre de classes.
  • 3. Une classe possède deux dimensions qui évoluent indépendamment, et les deux dimensions doivent être étendues.

6. Résumé du modèle

   
  • 1. Le modèle Pont réalise le découplage de l'abstraction et de l'implémentation. Ils sont indépendants l'un de l'autre et ne s'affectent pas mutuellement.
  • 2. Pour deux dimensions évoluant indépendamment, le modèle Pont est on ne peut plus approprié.
  • 3. Les modifications apportées à la "classe abstraite concrète" n'affecteront pas les clients.

URL d'origine : https://www.cnblogs.com/chenssy/3317866.html