Esempio di un esempio di bridge

Question

Ho trascorso un po 'di tempo su questo esempio di modello Bridge da wikipedia, tuttavia, non riesco ancora a capire cosa stia cercando di spiegare questo modello di bridge.

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

La sottoclasse CircleShape costruttore prende 4 args, nel suo metodo draw(), i primi 3 args vengono passati al 4 arg che può essere qualsiasi sottoclasse da DrawingAPI. Quindi, ciò significa che l'utilizzo del pattern bridge può aumentare la flessibilità? e ci sono altre cose che questo esempio può dirci?

Grazie !!!!

Answer 1

Un esempio più concreto del perché questo è utile lo renderà più chiaro. Supponi che DrawingAPI1 incapsuli il tuo driver grafico, mentre DrawingAPI2 fa la stessa cosa per il tuo driver di stampa. Quindi DrawingAPI è l'API generica per il tuo sistema grafico. Ti permette di disegnare una CircleShape sul tuo monitor e stamparla su un pezzo di carta usando lo stesso codice, devi solo passare nelle diverse implementazioni DrawingAPI. Tuttavia, se si passa DrawingAPI in Shape.draw() invece di passarlo al costruttore sarebbe più flessibile perché allora si può usare lo stesso oggetto grafico per il monitor e la stampante.

Answer 2

La sottoclasse CircleShape costruttore prende 4 args, nel suo metodo draw(), i primi 3 args vengono passati al 4 arg che può essere qualsiasi sottoclasse da DrawingAPI. Questo significa che l'utilizzo del pattern bridge 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'implementazione ed entrambi possono variare in modo diverso.

Da CircleShape utilizza composizione per contenere DrawingAPI senza ereditarietà, è possibile sostituire DrawingAPI API con una qualsiasi delle varie implementazioni di DrawingAPI

Shape e CircleShape possono variare indipendentemente senza dipendere il DrawingAPI.

è possibile trovare ulteriori dettagli sul modello Bridge in seguito SE post, che spiega esempio diverso:

Does the Bridge Pattern decouples an abstraction from implementation?