Bridge pattern

From Wikipedia, the free encyclopedia

Bridge in LePUS3 (legend)

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 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.

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

[edit] Examples

This article may be confusing or unclear to readers. Please help clarify the article; suggestions may be found on the talk page. (August 2007)

[edit] Structure

Abstraction

defines the abstract interface

maintains the Implementor reference

RefinedAbstraction

extends the interface defined by Abstraction

Implementor

defines the interface for implementation classes

ConcreteImplementor

implements the Implementor interface

[edit] Code examples

The Wikibook Computer Science/Design Patterns has a page on the topic of Bridge pattern implementations in various languages

[edit] Ruby

class Abstraction
  def initialize(implementor)
    @implementor = implementor
  end
 
  def operation
    raise 'Implementor object does not respond to the operation method' unless @implementor.respond_to?(:operation)
    @implementor.operation
  end
end
 
class RefinedAbstraction < Abstraction
  def operation
    puts 'Starting operation...'
    super
  end
end
 
class Implementor
  def operation
    puts 'Doing neccessary stuff'
  end
end
 
class ConcreteImplementorA < Implementor
  def operation
    super
    puts 'Doing additional stuff'
  end
end
 
class ConcreteImplementorB < Implementor
  def operation
    super
    puts 'Doing other additional stuff' 
  end
end
 
normal_with_a = Abstraction.new(ConcreteImplementorA.new)
normal_with_a.operation
# Doing neccessary stuff
# Doing additional stuff
 
normal_with_b = Abstraction.new(ConcreteImplementorB.new)
normal_with_b.operation
# Doing neccessary stuff
# Doing other additional stuff
 
refined_with_a = RefinedAbstraction.new(ConcreteImplementorA.new)
refined_with_a.operation
# Starting operation...
# Doing neccessary stuff
# Doing additional stuff
 
refined_with_b = RefinedAbstraction.new(ConcreteImplementorB.new)
refined_with_b.operation
# Starting operation...
# Doing neccessary stuff
# Doing other additional stuff

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

[edit] Scala

A Scala implementation of the Java drawing example with the same output.

 /** "Implementor" */
 trait DrawingAPI {
   def drawCircle(x:Double, y:Double, radius:Double)
 }
 
 /** "ConcreteImplementor" 1/2 */
 class DrawingAPI1 extends DrawingAPI {
   def drawCircle(x:Double, y:Double, radius:Double) {
     printf("API1.circle at %f:%f radius %f\n", x, y, radius)
   }
 }
 
 /** "ConcreteImplementor" 2/2 */
 class DrawingAPI2 extends DrawingAPI {
   def drawCircle(x:Double, y:Double, radius:Double) {
     printf("API2.circle at %f:%f radius %f\n", x, y, radius)
   }
 }
 
 /** "Abstraction" */
 trait Shape {
    def draw()                             // low-level
    def resizeByPercentage(pct:Double)     // high-level
 }
 
 /** "Refined Abstraction" */
 class CircleShape(var x:Double, var y:Double,
   var radius:Double, val drawingAPI:DrawingAPI) extends Shape {
   
   // low-level i.e. Implementation specific
   def draw() = drawingAPI.drawCircle(x, y, radius)
   
   // high-level i.e. Abstraction specific
   def resizeByPercentage(pct:Double) = radius *= pct
 }
 
 /** "Client" */
 val shapes = List(
   new CircleShape(1, 2, 3, new DrawingAPI1),
   new CircleShape(5, 7, 11, new DrawingAPI2)
 )
 
 shapes foreach { shape =>
   shape.resizeByPercentage(2.5)
   shape.draw()
 }

[edit] C++

#include <iostream>
 
/** "Implementor" */
class DrawingAPI {
public:
    virtual void drawCircle(double x, double y, double radius) = 0;
 
    virtual ~DrawingAPI() {
    }
};
 
/** "ConcreteImplementor" 1/2 */
class DrawingAPI1: public DrawingAPI {
public:
    DrawingAPI1() {
    }
 
    virtual ~DrawingAPI1() {
    }
 
    void drawCircle(double x, double y, double radius) {
        printf("\nAPI1.circle at %f:%f radius %f\n", x, y, radius);
    }
};
 
/** "ConcreteImplementor" 2/2 */
class DrawingAPI2: public DrawingAPI {
public:
    DrawingAPI2() {
    }
 
    virtual ~DrawingAPI2() {
    }
 
    void drawCircle(double x, double y, double radius) {
        printf("\nAPI2.circle at %f:%f radius %f\n", x, y, radius);
    }
};
 
/** "Abstraction" */
class Shape {
public:
    virtual void draw()= 0; // low-level
    virtual void resizeByPercentage(double pct) = 0; // high-level
    virtual ~Shape() {
    }
};
 
/** "Refined Abstraction" */
class CircleShape: public Shape {
public:
    CircleShape(double x, double y, double radius, DrawingAPI& drawingAPI) :
        x(x), y(y), radius(radius), drawingAPI(drawingAPI) {
    }
 
    virtual ~CircleShape() {
    }
 
    // low-level i.e. Implementation specific
    void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
    // high-level i.e. Abstraction specific
    void resizeByPercentage(double pct) {
        radius *= pct;
    }
private:
    double x, y, radius;
    DrawingAPI& drawingAPI;
};
 
int main(int argc, char* argv[]) {
    DrawingAPI1 api1;
    DrawingAPI2 api2;
 
    CircleShape c1(1, 2, 3, api1);
    CircleShape c2(5, 7, 11, api2);
 
    Shape* shapes[4];
    shapes[0] = &c1;
    shapes[1] = &c2;
 
    shapes[0]->resizeByPercentage(2.5);
    shapes[0]->draw();
    shapes[1]->resizeByPercentage(2.5);
    shapes[1]->draw();
 
    return 0;
}

[edit] D

import std.stdio;
 
/** "Implementor" */
interface DrawingAPI {
    void drawCircle(double x, double y, double radius);
}
 
/** "ConcreteImplementor" 1/2 */
class DrawingAPI1: DrawingAPI {
    void drawCircle(double x, double y, double radius) {
        writefln("\nAPI1.circle at %f:%f radius %f", x, y, radius);
    }
}
 
/** "ConcreteImplementor" 2/2 */
class DrawingAPI2: DrawingAPI {
    void drawCircle(double x, double y, double radius) {
        writefln("\nAPI2.circle at %f:%f radius %f", x, y, radius);
    }
}
 
/** "Abstraction" */
interface Shape {
    void draw(); // low-level
    void resizeByPercentage(double pct); // high-level
}
 
/** "Refined Abstraction" */
class CircleShape: Shape {
    this(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
    void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
    // high-level i.e. Abstraction specific
    void resizeByPercentage(double pct) {
        radius *= pct;
    }
private:
    double x, y, radius;
    DrawingAPI drawingAPI;
}
 
int main(string[] argv) {
    auto api1 = new DrawingAPI1();
    auto api2 = new DrawingAPI2();
 
    auto c1 = new CircleShape(1, 2, 3, api1);
    auto c2 = new CircleShape(5, 7, 11, api2);
 
    Shape[4] shapes;
    shapes[0] = c1;
    shapes[1] = c2;
 
    shapes[0].resizeByPercentage(2.5);
    shapes[0].draw();
    shapes[1].resizeByPercentage(2.5);
    shapes[1].draw();
 
    return 0;
}

[edit] Python

# Implementor
class drawing_api:
    def draw_circle(self, x, y, radius):
        pass
 
# ConcreteImplementor 1/2
class drawing_api1(drawing_api):
    def draw_circle(self, x, y, radius):
        print 'API1.circle at %f:%f radius %f' % (x, y, radius)
 
# ConcreteImplementor 2/2
class drawing_api2(drawing_api):
    def draw_circle(self, x, y, radius):
        print 'API2.circle at %f:%f radius %f' % (x, y, radius)
 
# Abstraction
class Shape:
    def draw(self):
        pass
 
    def resize_by_percentage(self, pct):
        pass
 
# Refined Abstraction
class CircleShape(Shape):
    def __init__(self, x, y, radius, drawing_api):
       self.x = x
       self.y = y
       self.radius = radius
       self.drawing_api = drawing_api
 
    def draw(self):
        self.drawing_api.draw_circle(self.x, self.y, self.radius)
 
    def resize_by_percentage(self, pct):
        self.radius *= pct
 
# Client
if __name__ == '__main__':
    shapes = [
        CircleShape(1, 2, 3, drawing_api1()),
        CircleShape(5, 7, 11, drawing_api2())
    ]
 
    for shape in shapes:
        shape.resize_by_percentage(2.5)
        shape.draw()

[edit] Perl

Note: This example uses the MooseX::Declare module.

# Implementor
role Drawing::API {
    requires 'draw_circle';
}
 
# Concrete Implementor 1
class Drawing::API::1 with Drawing::API {
    method draw_circle(Num $x, Num $y, Num $r) {
        printf "API1.circle at %f:%f radius %f\n", $x, $y, $r;
    }
}
 
# Concrete Implementor 2
class Drawing::API::2 with Drawing::API {
    method draw_circle(Num $x, Num $y, Num $r) {
        printf "API2.circle at %f:%f radius %f\n", $x, $y, $r;
    }
}
 
# Abstraction
role Shape {
    requires qw( draw resize );
}
 
# Refined Abstraction
class Shape::Circle with Shape {
    has $_  => ( is => 'rw', isa  => 'Any' ) for qw( x y r );
    has api => ( is => 'ro', does => 'Drawing::API' );
 
    method draw() {
        $self->api->draw_circle( $self->x, $self->y, $self->r );
    }
 
    method resize(Num $percentage) {
        $self->{r} *= $percentage;
    }
}
 
my @shapes = (
    Shape::Circle->new( x=>1, y=>2, r=>3,  api => Drawing::API::1->new ),
    Shape::Circle->new( x=>5, y=>7, r=>11, api => Drawing::API::2->new ),
)
 
$_->resize( 2.5 ) and $_->draw for @shapes;

[edit] See also

• Template method pattern
• Strategy pattern

[edit] References

[edit] External links

• Bridge in UML and in LePUS3 (a formal modelling language)
• "C# Design Patterns: The Bridge Pattern". Sample Chapter. http://www.informit.com/articles/article.aspx?p=30297.  From: James W. Cooper. C# Design Patterns: A Tutorial. Addison-Wesley. ISBN 0201844532. http://www.informit.com/store/product.aspx?isbn=0201844532. 
• Example of using Bridge pattern in Jt, J2EE Pattern Oriented Framework