Bridge pattern

From Wikipedia, the free encyclopedia

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

[edit] Shape abstraction

When the abstraction and implementation are separated, they can vary independently. Consider the abstraction of shapes. There are many types of shapes, each with its own properties. And there are things that all shapes do. One thing all shapes can do is draw themselves. However, drawing graphics to a screen can sometimes be dependent on different graphics implementations or operating systems. Shapes have to be able to be drawn on many types of operating systems. Having the shape itself implement them all, or modifying the shape class to work with different architectures is not practical. The bridge helps by allowing the creation of new implementation classes that provide the drawing implementation. The abstraction class, shape, provides methods for getting the size or properties of a shape. The implementation class, drawing, provides an interface for drawing graphics. If a new shape needs to be created or there is a new graphics API to be drawn on, then it is very easy to add a new implementation class that implements the needed features.^[2]

[edit] 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

[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] 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] See also

[edit] References

^ Gamma, E, Helm, R, Johnson, R, Vlissides, J: Design Patterns, page 151. Addison-Wesley, 1995
^ Shalloway; Trott. Design Patterns Explained: A New Perspective on Object-Oriented Design---.

[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

[0] Gamma, E, Helm, R, Johnson, R, Vlissides, J: Design Patterns, page 151. Addison-Wesley, 1995

[1] Shalloway; Trott. Design Patterns Explained: A New Perspective on Object-Oriented Design---.

[1]

[2]

Bridge pattern

From Wikipedia, the free encyclopedia

Contents

[edit] Examples

[edit] Shape abstraction

[edit] Structure

[edit] Code examples

[edit] Ruby

[edit] Java

[edit] Scala

[edit] C++

[edit] Python

[edit] See also

[edit] References

[edit] External links

Views

Personal tools

Navigation

Search

Interaction

Toolbox

Languages