Un esempio di Bridge Bridge

Question

Ho trascorso un po 'di tempo su questo esempio di pattern Bridge da wikipedia , tuttavia, continuo a non capisco cosa stia cercando di spiegare questo schema a ponte.

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);
   }
}

/** "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;
   }
}

/** "Client" */
class Main {
   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();
       }
   }
}

Il costruttore CircleShape della sottoclasse accetta 4 arg, nel suo metodo draw (), i primi 3 arg vengono passati al 4o arg che può essere qualsiasi sottoclasse da DrawingAPI. Questo significa che l'utilizzo del modello a ponte può aumentare la flessibilità? e ci sono altre cose che questo esempio può dirci?

Grazie !!!!

Answer 1

Un esempio più concreto del perché questo sia utile lo renderà più chiaro. Supponiamo che DrawingAPI1 incapsuli il driver grafico, mentre DrawingAPI2 faccia la stessa cosa per il driver della stampante. Quindi DrawingAPI è l'API generica per il tuo sistema grafico. Ti permette di disegnare un CircleShape sul tuo monitor e stamparlo su un pezzo di carta usando lo stesso codice, devi solo passare le diverse implementazioni di DrawingAPI. Tuttavia, se si passa DrawingAPI in Shape.draw () invece di passarlo nel costruttore sarebbe più flessibile perché quindi è possibile utilizzare lo stesso grafico a oggetti per il monitor e la stampante.

Answer 2

  

Il costruttore CircleShape della sottoclasse accetta 4 arg, nel suo metodo draw (), i primi 3 arg vengono passati al 4o arg che può essere qualsiasi sottoclasse da DrawingAPI. Questo significa che l'utilizzo del modello a ponte può aumentare la flessibilità? e ci sono altre cose che questo esempio può dirci?

Non è solo la flessibilità. Il modello Bridge disaccoppia l'astrazione dall'attuazione ed entrambi possono variare in modo diverso .

Poiché CircleShape utilizza la composizione per contenere DrawingAPI senza ereditarietà, è possibile sostituire l'API DrawingAPI con una qualsiasi delle molteplici implementazioni di DrawingAPI

Shape e CircleShape possono cambiare indipendentemente senza dipendenza da DrawingAPI .

Puoi trovare maggiori dettagli sul modello Bridge sotto il post SE, che spiega diversi esempi:

Bridge Pattern disaccoppia un'astrazione dall'implementazione?