Bridge

The bridge pattern is a design pattern used in software engineering which is meant to "decouple an abstraction from its implementation so that the two can vary independently" . The bridge uses encapsulation , aggregation , and can use inheritance to separate responsibilities into different classes .

When a class varies often, the features of object-oriented programming become very useful because changes to a program 's code can be made easily with minimal prior knowledge about the program. The bridge pattern is useful when both the class as well as what it does varies. The class itself can be thought of as the implementation and what the class can do as the abstraction . The bridge pattern can also be thought of as two layers of abstraction.

Structure

Abstraction

defines the abstract interface

maintains the Implementor reference

Refined Abstraction

extends the interface defined by Abstraction

Implementor

defines the interface for implementation classes

ConcreteImplementor

implements the Implementor interface

Java

The following Java (SE 6) program illustrates the 'shape' example given above and will output:

API1.circle at 1.000000:2.000000 radius 7.500000


API2.circle at 5.000000:7.000000 radius 27.500000

/** "Implementor" */

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 BridgePattern {

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

       }

   }

}