Bridge pattern

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.

When there is only one fixed implementation, this pattern is known as the Pimpl idiom in the C++ world.

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.

Structure

Bridge UML class diagram.svg

Abstraction (abstract class)
defines the abstract interface
maintains the Implementor reference.
RefinedAbstraction (normal class)
extends the interface defined by Abstraction
Implementor (interface)
defines the interface for implementation classes
ConcreteImplementor (normal class)
implements the Implementor interface
Bridge in LePUS3 (legend)

Example

Java

The following Java (SE 6) program illustrates the 'shape' example given below.

/** "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 abstract void draw();                             // low-level
    public abstract 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();
        }
    }
}

It will output:

API1.circle at 1.000000:2.000000 radius 7.5000000
API2.circle at 5.000000:7.000000 radius 27.500000

PHP

interface DrawingAPI {
    function drawCircle($dX, $dY, $dRadius);
}
 
class DrawingAPI1 implements DrawingAPI {
 
    public function drawCircle($dX, $dY, $dRadius) {
        echo "API1.circle at $dX:$dY radius $dRadius.<br/>";
    }
}
 
class DrawingAPI2 implements DrawingAPI {
 
    public function drawCircle($dX, $dY, $dRadius) {
        echo "API2.circle at $dX:$dY radius $dRadius.<br/>";
    }
}
 
abstract class Shape {
 
    protected $oDrawingAPI;
 
    public abstract function draw();
    public abstract function resizeByPercentage($dPct);
 
    protected function __construct(DrawingAPI $oDrawingAPI) {
        $this->oDrawingAPI = $oDrawingAPI;
    }
}
 
class CircleShape extends Shape {
 
    private $dX;
    private $dY;
    private $dRadius;
 
    public function __construct($dX, $dY, $dRadius, DrawingAPI $oDrawingAPI) {
        parent::__construct($oDrawingAPI);
        $this->dX = $dX;
        $this->dY = $dY;
        $this->dRadius = $dRadius;
    }
 
    public function draw() {
        $this->oDrawingAPI->drawCircle(
                $this->dX,
                $this->dY,
                $this->dRadius
        );
    }
 
    public function resizeByPercentage($dPct) {
        $this->dRadius *= $dPct;
    }
}
 
class Tester {
 
    public static function main()  {
        $aShapes = array(
            new CircleShape(1, 3, 7,  new DrawingAPI1()),
            new CircleShape(5, 7, 11, new DrawingAPI2()),
        );
 
        foreach ($aShapes as $shape) {
            $shape->resizeByPercentage(2.5);
            $shape->draw();
        }
    }
}
 
Tester::main();

Output:

API1.circle at 1:3 radius 17.5
API2.circle at 5:7 radius 27.5

Scala

trait DrawingAPI {
  def drawCircle(x: Double, y: Double, radius: Double)
}
 
class DrawingAPI1 extends DrawingAPI {
  def drawCircle(x: Double, y: Double, radius: Double) = println(s"API #1 $x $y $radius")
}
 
class DrawingAPI2 extends DrawingAPI {
  def drawCircle(x: Double, y: Double, radius: Double) = println(s"API #2 $x $y $radius")
}
 
abstract class Shape(drawingAPI: DrawingAPI) {
  def draw()
  def resizePercentage(pct: Double)
}
 
class CircleShape(x: Double, y: Double, var radius: Double, drawingAPI: DrawingAPI)
    extends Shape(drawingAPI: DrawingAPI) {
 
  def draw() = drawingAPI.drawCircle(x, y, radius)
 
  def resizePercentage(pct: Double) { radius *= pct }
}
 
object BridgePattern {
  def main(args: Array[String]) {
    Seq (
	new CircleShape(1, 3, 5, new DrawingAPI1),
	new CircleShape(4, 5, 6, new DrawingAPI2)
    ) foreach { x => 
        x.resizePercentage(3)
        x.draw()			
      }	
  }
}

See also

References

  1. ^ Gamma, E, Helm, R, Johnson, R, Vlissides, J: Design Patterns, page 151. Addison-Wesley, 1995

External links

GoF Patterns
Concurrency Patterns
Architectural Patterns
Other Patterns
Books
People
Communities
fonte: https://web.archive.org/web/20140803050628/https://en.wikipedia.org/wiki/Bridge_pattern