Patron Pont

Le pont est utilisé pour découpler l'abstraction de l'implémentation afin que les deux puissent varier indépendamment. Ce type de patron de conception est un patron structurel, qui découple les deux en fournissant une structure de pont entre l'abstraction et l'implémentation.

Ce patron implique une interface qui agit comme un pont, de sorte que la fonctionnalité des classes d'entités soit indépendante des classes d'implémentation de l'interface. Ces deux types de classes peuvent être modifiés structurellement sans s'affecter mutuellement.

Le but du patron Pont est de séparer l'abstraction de l'implémentation afin qu'elles puissent varier indépendamment. Le patron sépare la partie abstraite d'un objet de sa partie implémentation, ce qui leur permet de changer indépendamment. Il relie les parties abstraite et implémentation par composition plutôt que par héritage.

Nous utilisons l'exemple suivant pour démontrer l'utilisation du patron Pont. Ici, nous pouvons utiliser les mêmes méthodes de classe abstraite mais différentes classes d'implémentation de pont pour dessiner des cercles de couleurs différentes.

Introduction

intention

Utilisé pour séparer la partie abstraite de la partie implémentation afin qu'elles puissent varier indépendamment.

Principaux problèmes résolus

Évite le problème d'explosion des classes causé par l'héritage et offre une manière plus flexible d'étendre.

Cas d'utilisation

Le patron Bridge est adapté lorsqu'un système peut être classé selon plusieurs perspectives et que chaque perspective peut varier indépendamment.

Approche d'implémentation

  • Séparation de la classification multi-angles: Sépare la logique de classification selon différentes perspectives, ce qui leur permet de varier indépendamment.
  • Réduire le couplage: Réduit le couplage entre l'abstraction et l'implémentation.

Code clé

  • Classe abstraite: Définit une classe abstraite comme partie du système.
  • Classe d'implémentation: Définit une ou plusieurs classes d'implémentation qui sont associées à la classe abstraite par agrégation (plutôt que par héritage).

Exemple d'application

  • Réincarnation: La séparation de l'âme (abstraction) et du corps (implémentation), permettant à l'âme de choisir différents corps.
  • Interrupteur mural: La séparation de l'interrupteur (abstraction) et de l'implémentation interne (implémentation) ; les utilisateurs n'ont pas besoin de se soucier du mécanisme de fonctionnement interne de l'interrupteur.

Avantages

  • Séparation de l'abstraction et de l'implémentation: Améliore la flexibilité et la maintenabilité du système.
  • Forte extensibilité: L'abstraction et l'implémentation peuvent être étendues indépendamment.
  • Détails d'implémentation transparents: Les utilisateurs n'ont pas besoin de comprendre les détails d'implémentation.

Inconvénients

  • Difficulté de compréhension et de conception: Le patron Pont augmente la difficulté de compréhension et de conception du système.
  • Association d'agrégation: Exige des développeurs qu'ils conçoivent et programment au niveau d'abstraction.

Suggestions d'utilisation

  • Utilisez le patron Pont lorsque le système doit augmenter la flexibilité entre le rôle d'abstraction et le rôle concret.
  • Le patron Pont est particulièrement adapté aux systèmes où l'héritage n'est pas souhaitable ou où l'héritage à plusieurs niveaux provoque une forte augmentation du nombre de classes.
  • Utilisez le patron Pont lorsqu'une classe possède deux dimensions variant indépendamment et que les deux dimensions doivent être étendues.

Notes

  • Le patron Pont convient à deux dimensions variant indépendamment, garantissant qu'elles peuvent être étendues et modifiées indépendamment.

Structure

Voici plusieurs rôles clés du patron Pont :

  • Abstraction : Définit l'interface abstraite, contenant généralement une référence à l'interface d'implémentation.
  • Abstraction raffinée : Une extension de l'abstraction, qui peut être une sous-classe de la classe abstraite ou une classe d'implémentation concrète.
  • Implémenteur : Définit l'interface d'implémentation et fournit l'interface pour les opérations de base.
  • Implémenteur concret : Une classe concrète qui implémente l'interface d'implémentation.

Implémentation

Nous avons une ... comme implémentation du pont.DrawAPIInterfaces et implémentationsDrawAPIClasses d'entité de l'interfaceRedCircle、GreenCircle。Shapeest une classe abstraite qui utiliseraDrawAPIl'objet.BridgePatternDemoUtilisation de la classeShapeclasse pour dessiner des cercles de différentes couleurs.

桥接模式的 UML 图

Étape 1

Créer une interface d'implémentation de pont.

DrawAPI.java

public interface DrawAPI { public void drawCircle(int radius, int x, int y); }

Étape 2

Créer une implémentationDrawAPIClasses d'implémentation concrètes du pont pour l'interface.

RedCircle.java

public class RedCircle implements DrawAPI { @Override public void drawCircle(int radius, int x, int y) { System.out.println("Dessin d'un cercle[ couleur: rouge, rayon: " + radius +", x: " +x+", "+ y +"]"); } }

GreenCircle.java

public class GreenCircle implements DrawAPI { @Override public void drawCircle(int radius, int x, int y) { System.out.println("Dessin d'un cercle[ couleur: vert, rayon: " + radius +", x: " +x+", "+ y +"]"); } }

Étape 3

UtilisationDrawAPICréation de classes abstraites à partir d'interfacesShape。

Shape.java

public abstract class Shape { protected DrawAPI drawAPI; protected Shape(DrawAPI drawAPI){ this.drawAPI = drawAPI; } public abstract void draw(); }

Étape 4

Créer une implémentationShapeClasses concrètes de la classe abstraite.

Circle.java

public class Circle extends Shape { private int x, y, radius; public Circle(int x, int y, int radius, DrawAPI drawAPI) { super(drawAPI); this.x = x; this.y = y; this.radius = radius; } public void draw() { drawAPI.drawCircle(radius,x,y); } }

Étape 5

UtilisationShapeetDrawAPILa classe dessine des cercles de différentes couleurs.

BridgePatternDemo.java

public class BridgePatternDemo { public static void main(String[] args) { Shape redCircle = new Circle(100,100, 10, new RedCircle()); Shape greenCircle = new Circle(100,100, 10, new GreenCircle()); redCircle.draw(); greenCircle.draw(); } }

Étape 6

Exécutez le programme, affichez les résultats :

Drawing Circle[ color: red, radius: 10, x: 100, 100]
Drawing Circle[  color: green, radius: 10, x: 100, 100]

Recommandations d'articles connexes

Patron Pont

autres extensions