Jump to content
Wikipedia The Free Encyclopedia

Bridge pattern

From Wikipedia, the free encyclopedia
The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.
Design pattern used in software engineering

The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently", introduced by the Gang of Four.[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 and what it does vary often. The class itself can be thought of as the abstraction and what the class can do as the implementation. 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, and is often implemented using the object 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.

Overview

The Bridge design pattern is one of the twenty-three well-known GoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.[1]

What problems can the Bridge design pattern solve?[2]

  • An abstraction and its implementation should be defined and extended independently from each other.
  • A compile-time binding between an abstraction and its implementation should be avoided so that an implementation can be selected at run-time.

When using subclassing, different subclasses implement an abstract class in different ways. But an implementation is bound to the abstraction at compile-time and cannot be changed at run-time.

What solution does the Bridge design pattern describe?

  • Separate an abstraction (Abstraction) from its implementation (Implementor) by putting them in separate class hierarchies.
  • Implement the Abstraction in terms of (by delegating to) an Implementor object.

This enables to configure an Abstraction with an Implementor object at run-time.
See also the Unified Modeling Language class and sequence diagram below.

Structure

UML class and sequence diagram

A sample UML class and sequence diagram for the Bridge design pattern.[3]

In the above Unified Modeling Language class diagram, an abstraction (Abstraction) is not implemented as usual in a single inheritance hierarchy. Instead, there is one hierarchy for an abstraction (Abstraction) and a separate hierarchy for its implementation (Implementor), which makes the two independent from each other. The Abstraction interface (operation()) is implemented in terms of (by delegating to) the Implementor interface (imp.operationImp()).
The UML sequence diagram shows the run-time interactions: The Abstraction1 object delegates implementation to the Implementor1 object (by calling operationImp() on Implementor1), which performs the operation and returns to Abstraction1.

Class diagram

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

C#

Bridge pattern compose objects in tree structure. It decouples abstraction from implementation. Here abstraction represents the client from which the objects will be called. An example implemented in C# is given below

namespaceWikipedia.Examples;
usingSystem;
// Helps in providing truly decoupled architecture
interfaceIBridge
{
voidFunction1();
voidFunction2();
}
classBridge1:IBridge
{
publicvoidFunction1()
{
Console.WriteLine("Bridge1.Function1");
}
publicvoidFunction2()
{
Console.WriteLine("Bridge1.Function2");
}
}
classBridge2:IBridge
{
publicvoidFunction1()
{
Console.WriteLine("Bridge2.Function1");
}
publicvoidFunction2()
{
Console.WriteLine("Bridge2.Function2");
}
}
interfaceIAbstractBridge
{
voidCallMethod1();
voidCallMethod2();
}
classAbstractBridge:IAbstractBridge
{
publicIBridgebridge;
publicAbstractBridge(IBridgebridge)
{
this.bridge=bridge;
}
publicvoidCallMethod1()
{
this.bridge.Function1();
}
publicvoidCallMethod2()
{
this.bridge.Function2();
}
}

The Bridge classes are the Implementation that uses the same interface-oriented architecture to create objects. On the other hand, the abstraction takes an instance of the implementation class and runs its method. Thus, they are completely decoupled from one another.

Crystal

abstractclassDrawingAPI
abstractdefdraw_circle(x:Float64,y:Float64,radius:Float64)
end
classDrawingAPI1<DrawingAPI
defdraw_circle(x:Float,y:Float,radius:Float)
"API1.circle at #{x}:#{y} - radius: #{radius}"
end
end
classDrawingAPI2<DrawingAPI
defdraw_circle(x:Float64,y:Float64,radius:Float64)
"API2.circle at #{x}:#{y} - radius: #{radius}"
end
end
abstractclassShape
protectedgetterdrawing_api:DrawingAPI
definitialize(@drawing_api)
end
abstractdefdraw
abstractdefresize_by_percentage(percent:Float64)
end
classCircleShape<Shape
getterx:Float64
gettery:Float64
getterradius:Float64
definitialize(@x,@y,@radius,drawing_api:DrawingAPI)
super(drawing_api)
end
defdraw
@drawing_api.draw_circle(@x,@y,@radius)
end
defresize_by_percentage(percent:Float64)
@radius*=(1+percent/100)
end
end
classBridgePattern
defself.test
shapes=[]ofShape
shapes<<CircleShape.new(1.0,2.0,3.0,DrawingAPI1.new)
shapes<<CircleShape.new(5.0,7.0,11.0,DrawingAPI2.new)
shapes.eachdo|shape|
shape.resize_by_percentage(2.5)
putsshape.draw
end
end
end
BridgePattern.test

Output

API1.circle at 1.0:2.0 - radius: 3.075
API2.circle at 5.0:7.0 - radius: 11.275

C++

importstd;
usingstd::string;
usingstd::vector;
classDrawingAPI{
public:
virtual~DrawingAPI()=default;
virtualstringdrawCircle(floatx,floaty,floatradius)const=0;
};
classDrawingAPI01:publicDrawingAPI{
public:
[[nodiscard]]
stringdrawCircle(floatx,floaty,floatradius)constoverride{
returnstd::format("API01.circle at {}:{} - radius: {}",x,y,radius);
}
};
classDrawingAPI02:publicDrawingAPI{
public:
[[nodiscard]]
stringdrawCircle(floatx,floaty,floatradius)constoverride{
returnstd::format("API02.circle at {}:{} - radius: {}",x,y,radius);
}
};
classShape{
protected:
constDrawingAPI&drawingApi;
public:
Shape(constDrawingAPI&api):
drawingApi{api}{}
virtual~Shape()=default;
virtualstringdraw()const=0;
virtualfloatresizeByPercentage(constfloatpercent)noexcept=0;
};
classCircleShape:publicShape{
private:
floatx;
floaty;
floatradius;
public:
CircleShape(constDrawingAPI&api,floatx,floaty,floatradius):
Shape(api),x{x},y{y},radius{radius}{}
[[nodiscard]]
stringdraw()constoverride{
returndrawingApi.drawCircle(x,y,radius);
}
[[nodiscard]]
floatresizeByPercentage(floatpercent)noexceptoverride{
returnradius*=(1.0f+percent/100.0f);
}
};
intmain(intargc,char*argv[]){
constDrawingAPI01api1;
constDrawingAPI02api2;
vector<CircleShape>shapes{
CircleShape{api1,1.0f,2.0f,3.0f},
CircleShape{api2,5.0f,7.0f,11.0f}
};
for(CircleShape&shape:shapes){
shape.resizeByPercentage(2.5);
std::println("{}",shape.draw());
}
return0;
}

Output:

API01.circle at 1.000000:2.000000 - radius: 3.075000
API02.circle at 5.000000:7.000000 - radius: 11.275000

Code requires a C++23 capable compiler, e.g. on Ubuntu 26.06 LTS with g++-15 the following 2-step build is required:

g++-15 -std=c++23 -c -fmodules -fmodule-only -fsearch-include-path bits/std.cc
g++-15 -std=c++23 -fmodules -o program program.cpp

Java

The following Java program defines a bank account that separates the account operations from the logging of these operations. 

packageorg.wikipedia.examples;
// Logger has two implementations: info and warning
@FunctionalInterface
interface Logger{
voidlog(Stringmessage);

staticLoggerinfo(){
returnmessage->System.out.printf("info: %s%n",message);
}
staticLoggerwarning(){
returnmessage->System.out.printf("warning: %s%n",message);
}
}
abstractclass AbstractAccount{
privateLoggerlogger=Logger.info();

publicvoidsetLogger(Loggerlogger){
this.logger=logger;
}

// the logging part is delegated to the Logger implementation
protectedvoidoperate(Stringmessage,booleanresult){
logger.log(String.format("%s result %s",message,result));
}
}
class SimpleAccountextendsAbstractAccount{
privateintbalance;

publicSimpleAccount(intbalance){
this.balance=balance;
}

publicbooleanisBalanceLow(){
returnbalance<50;
}

publicvoidwithdraw(intamount){
booleanshouldPerform=balance>=amount;
if(shouldPerform){
balance-=amount;
}
operate(String.format("withdraw %s",amount,shouldPerform));
}
}
publicclass BridgeDemo{
publicstaticvoidmain(String[]args){
SimpleAccountaccount=newSimpleAccount(100);
account.withdraw(75);

if(account.isBalanceLow()){
// you can also change the Logger implementation at runtime
account.setLogger(Logger.warning());
}

account.withdraw(10);
account.withdraw(100);
}
}

It will output:

info: withdraw 75 result true
warning: withdraw 10 result true
warning: withdraw 100 result false

PHP

interface DrawingAPI
{
 function drawCircle($x, $y, $radius);
}
class DrawingAPI1 implements DrawingAPI
{
 public function drawCircle($x, $y, $radius)
 {
 echo "API1.circle at $x:$y radius $radius.\n";
 }
}
class DrawingAPI2 implements DrawingAPI
{
 public function drawCircle($x, $y, $radius)
 {
 echo "API2.circle at $x:$y radius $radius.\n";
 }
}
abstract class Shape
{
 protected $drawingAPI;
 public abstract function draw();
 public abstract function resizeByPercentage($pct);
 protected function __construct(DrawingAPI $drawingAPI)
 {
 $this->drawingAPI = $drawingAPI;
 }
}
class CircleShape extends Shape
{
 private $x;
 private $y;
 private $radius;
 public function __construct($x, $y, $radius, DrawingAPI $drawingAPI)
 {
 parent::__construct($drawingAPI);
 $this->x = $x;
 $this->y = $y;
 $this->radius = $radius;
 }
 public function draw()
 {
 $this->drawingAPI->drawCircle($this->x, $this->y, $this->radius);
 }
 public function resizeByPercentage($pct)
 {
 $this->radius *= $pct;
 }
}
class Tester
{
 public static function main()
 {
 $shapes = array(
 new CircleShape(1, 3, 7, new DrawingAPI1()),
 new CircleShape(5, 7, 11, new DrawingAPI2()),
 );
 foreach ($shapes 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

traitDrawingAPI{
defdrawCircle(x:Double,y:Double,radius:Double)
}
classDrawingAPI1extendsDrawingAPI{
defdrawCircle(x:Double,y:Double,radius:Double)=println(s"API #1 $x$y$radius")
}
classDrawingAPI2extendsDrawingAPI{
defdrawCircle(x:Double,y:Double,radius:Double)=println(s"API #2 $x$y$radius")
}
abstractclassShape(drawingAPI:DrawingAPI){
defdraw()
defresizePercentage(pct:Double)
}
classCircleShape(x:Double,y:Double,varradius:Double,drawingAPI:DrawingAPI)
extendsShape(drawingAPI:DrawingAPI){
defdraw()=drawingAPI.drawCircle(x,y,radius)
defresizePercentage(pct:Double){radius*=pct}
}
objectBridgePattern{
defmain(args:Array[String]){
Seq(
newCircleShape(1,3,5,newDrawingAPI1),
newCircleShape(4,5,6,newDrawingAPI2)
)foreach{x=>
x.resizePercentage(3)
x.draw()
}
}
}

Python

"""
Bridge pattern example.
"""
fromabcimport ABCMeta, abstractmethod
fromtypingimport NoReturn
NOT_IMPLEMENTED: str = "You should implement this."
classDrawingAPI:
 __metaclass__ = ABCMeta
 @abstractmethod
 defdraw_circle(self, x: float, y: float, radius: float) -> NoReturn:
 raise NotImplementedError(NOT_IMPLEMENTED)
classDrawingAPI1(DrawingAPI):
 defdraw_circle(self, x: float, y: float, radius: float) -> str:
 return f"API1.circle at {x}:{y} - radius: {radius}"
classDrawingAPI2(DrawingAPI):
 defdraw_circle(self, x: float, y: float, radius: float) -> str:
 return f"API2.circle at {x}:{y} - radius: {radius}"
classDrawingAPI3(DrawingAPI):
 defdraw_circle(self, x: float, y: float, radius: float) -> str:
 return f"API3.circle at {x}:{y} - radius: {radius}"
classShape:
 __metaclass__ = ABCMeta
 drawing_api: DrawingAPI = None
 def__init__(self, drawing_api: DrawingAPI) -> None:
 self.drawing_api = drawing_api
 @abstractmethod
 defdraw(self) -> NoReturn:
 raise NotImplementedError(NOT_IMPLEMENTED)
 @abstractmethod
 defresize_by_percentage(self, percent: float) -> NoReturn:
 raise NotImplementedError(NOT_IMPLEMENTED)
classCircleShape(Shape):
 def__init__(self, x: float, y: float, radius: float, drawing_api: DrawingAPI):
 self.x = x
 self.y = y
 self.radius = radius
 super(CircleShape, self).__init__(drawing_api)
 defdraw(self) -> str:
 return self.drawing_api.draw_circle(self.x, self.y, self.radius)
 defresize_by_percentage(self, percent: float) -> None:
 self.radius *= 1 + percent / 100
classBridgePattern:
 @staticmethod
 deftest() -> None:
 shapes: list[CircleShape] = [
 CircleShape(1.0, 2.0, 3.0, DrawingAPI1()),
 CircleShape(5.0, 7.0, 11.0, DrawingAPI2()),
 CircleShape(5.0, 4.0, 12.0, DrawingAPI3()),
 ]
 for shape in shapes:
 shape.resize_by_percentage(2.5)
 print(shape.draw())
if __name__ == "__main__":
 BridgePattern.test()

See also

References

AltStyle によって変換されたページ (->オリジナル) /