Posted in Uncategorized

Bridge Pattern

Definition

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”.[1] 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 vary often. 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.

The bridge pattern is often confused with the adapter pattern. In fact, the bridge pattern is often implemented using the class adapter pattern, e.g. in the Java code below.

Variant: The implementation can be decoupled even more by deferring the presence of the implementation to the point where the abstraction is utilized.

Related pattern:

Template Pattern, Strategy Pattern

Similar Pattern:

Adapter Pattern

/** "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" */ abstract class Shape {    protected DrawingAPI drawingAPI;      protected Shape(DrawingAPI drawingAPI){       this.drawingAPI = drawingAPI;    }      public void draw();                             // low-level    public void resizeByPercentage(double pct);     // high-level }   /** "Refined Abstraction" */ class CircleShape extends Shape {    private double x, y, radius;    public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI) {       super(drawingAPI);       this.x = x;  this.y = y;  this.radius = radius;     }      // 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[] {            new CircleShape(1, 2, 3, new DrawingAPI1()),            new CircleShape(5, 7, 11, new DrawingAPI2()),        };          for (Shape shape : shapes) {            shape.resizeByPercentage(2.5);            shape.draw();        }    } }

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s