Thebridge pattern is adesign pattern used insoftware engineering that is meant to"decouple anabstraction from itsimplementation so that the two can vary independently", introduced by theGang of Four.[1] Thebridge usesencapsulation,aggregation, and can useinheritance to separate responsibilities into differentclasses.
When a class varies often, the features ofobject-oriented programming become very useful because changes to aprogram'scode 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 theabstraction and what the class can do as theimplementation. 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 thePimpl idiom in theC++ world.
The bridge pattern is often confused with theadapter pattern, and is often implemented using theobject 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.
The Bridge design pattern is one of the twenty-three well-knownGoF 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]
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?
Abstraction) from its implementation (Implementor) by putting them in separate class hierarchies.Abstraction in terms of (by delegating to) anImplementor object.This enables to configure anAbstraction with anImplementor object at run-time.
See also theUnified Modeling Language class and sequence diagram below.
In the above Unified Modeling Languageclass diagram, an abstraction (Abstraction) is not implemented as usual in a single inheritance hierarchy.Instead, there is one hierarchy foran abstraction (Abstraction) and a separate hierarchy for its implementation (Implementor), which makes the two independent from each other.TheAbstraction interface (operation()) is implemented in terms of (by delegating to)theImplementor interface (imp.operationImp()).
TheUMLsequence diagramshows the run-time interactions: TheAbstraction1 object delegates implementation to theImplementor1 object (by callingoperationImp() onImplementor1),which performs the operation and returns toAbstraction1.
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 architectureinterfaceIBridge{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.
abstractclassDrawingAPIabstractdefdraw_circle(x:Float64,y:Float64,radius:Float64)endclassDrawingAPI1<DrawingAPIdefdraw_circle(x:Float,y:Float,radius:Float)"API1.circle at#{x}:#{y} - radius:#{radius}"endendclassDrawingAPI2<DrawingAPIdefdraw_circle(x:Float64,y:Float64,radius:Float64)"API2.circle at#{x}:#{y} - radius:#{radius}"endendabstractclassShapeprotectedgetterdrawing_api:DrawingAPIdefinitialize(@drawing_api)endabstractdefdrawabstractdefresize_by_percentage(percent:Float64)endclassCircleShape<Shapegetterx:Float64gettery:Float64getterradius:Float64definitialize(@x,@y,@radius,drawing_api:DrawingAPI)super(drawing_api)enddefdraw@drawing_api.draw_circle(@x,@y,@radius)enddefresize_by_percentage(percent:Float64)@radius*=(1+percent/100)endendclassBridgePatterndefself.testshapes=[]ofShapeshapes<<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.drawendendendBridgePattern.test
Output
API1.circle at 1.0:2.0 - radius: 3.075API2.circle at 5.0:7.0 - radius: 11.275
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{returnapi.drawCircle(x,y,radius);}[[nodiscard]]floatresizeByPercentage(floatpercent)noexceptoverride{returnradius*=(1.0f+percent/100.0f);}};intmain(intargc,char*argv[]){constDrawingAPI01api1;constDrawingAPI02api2;vector<CircleShape>shapes{CircleShape{1.0f,2.0f,3.0f,api1},CircleShape{5.0f,7.0f,11.0f,api2}};for(CircleShape&shape:shapes){shape.resizeByPercentage(2.5);std::println("{}",shape.draw());}return0;}
Output:
API01.circle at 1.000000:2.000000 - radius: 3.075000API02.circle at 5.000000:7.000000 - radius: 11.275000
The followingJava 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@FunctionalInterfaceinterfaceLogger{voidlog(Stringmessage);staticLoggerinfo(){returnmessage->System.out.printf("info: %s%n",message);}staticLoggerwarning(){returnmessage->System.out.printf("warning: %s%n",message);}}abstractclassAbstractAccount{privateLoggerlogger=Logger.info();publicvoidsetLogger(Loggerlogger){this.logger=logger;}// the logging part is delegated to the Logger implementationprotectedvoidoperate(Stringmessage,booleanresult){logger.log(String.format("%s result %s",message,result));}}classSimpleAccountextendsAbstractAccount{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));}}publicclassBridgeDemo{publicstaticvoidmain(String[]args){SimpleAccountaccount=newSimpleAccount(100);account.withdraw(75);if(account.isBalanceLow()){// you can also change the Logger implementation at runtimeaccount.setLogger(Logger.warning());}account.withdraw(10);account.withdraw(100);}}
It will output:
info: withdraw 75 result truewarning: withdraw 10 result truewarning: withdraw 100 result false
interfaceDrawingAPI{functiondrawCircle($x,$y,$radius);}classDrawingAPI1implementsDrawingAPI{publicfunctiondrawCircle($x,$y,$radius){echo"API1.circle at$x:$y radius$radius.\n";}}classDrawingAPI2implementsDrawingAPI{publicfunctiondrawCircle($x,$y,$radius){echo"API2.circle at$x:$y radius$radius.\n";}}abstractclassShape{protected$drawingAPI;publicabstractfunctiondraw();publicabstractfunctionresizeByPercentage($pct);protectedfunction__construct(DrawingAPI$drawingAPI){$this->drawingAPI=$drawingAPI;}}classCircleShapeextendsShape{private$x;private$y;private$radius;publicfunction__construct($x,$y,$radius,DrawingAPI$drawingAPI){parent::__construct($drawingAPI);$this->x=$x;$this->y=$y;$this->radius=$radius;}publicfunctiondraw(){$this->drawingAPI->drawCircle($this->x,$this->y,$this->radius);}publicfunctionresizeByPercentage($pct){$this->radius*=$pct;}}classTester{publicstaticfunctionmain(){$shapes=array(newCircleShape(1,3,7,newDrawingAPI1()),newCircleShape(5,7,11,newDrawingAPI2()),);foreach($shapesas$shape){$shape->resizeByPercentage(2.5);$shape->draw();}}}Tester::main();
Output:
API1.circle at 1:3 radius 17.5API2.circle at 5:7 radius 27.5
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()}}}
"""Bridge pattern example."""fromabcimportABCMeta,abstractmethodfromtypingimportNoReturnNOT_IMPLEMENTED:str="You should implement this."classDrawingAPI:__metaclass__=ABCMeta@abstractmethoddefdraw_circle(self,x:float,y:float,radius:float)->NoReturn:raiseNotImplementedError(NOT_IMPLEMENTED)classDrawingAPI1(DrawingAPI):defdraw_circle(self,x:float,y:float,radius:float)->str:returnf"API1.circle at{x}:{y} - radius:{radius}"classDrawingAPI2(DrawingAPI):defdraw_circle(self,x:float,y:float,radius:float)->str:returnf"API2.circle at{x}:{y} - radius:{radius}"classDrawingAPI3(DrawingAPI):defdraw_circle(self,x:float,y:float,radius:float)->str:returnf"API3.circle at{x}:{y} - radius:{radius}"classShape:__metaclass__=ABCMetadrawing_api:DrawingAPI=Nonedef__init__(self,drawing_api:DrawingAPI)->None:self.drawing_api=drawing_api@abstractmethoddefdraw(self)->NoReturn:raiseNotImplementedError(NOT_IMPLEMENTED)@abstractmethoddefresize_by_percentage(self,percent:float)->NoReturn:raiseNotImplementedError(NOT_IMPLEMENTED)classCircleShape(Shape):def__init__(self,x:float,y:float,radius:float,drawing_api:DrawingAPI):self.x=xself.y=yself.radius=radiussuper(CircleShape,self).__init__(drawing_api)defdraw(self)->str:returnself.drawing_api.draw_circle(self.x,self.y,self.radius)defresize_by_percentage(self,percent:float)->None:self.radius*=1+percent/100classBridgePattern:@staticmethoddeftest()->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()),]forshapeinshapes:shape.resize_by_percentage(2.5)print(shape.draw())if__name__=="__main__":BridgePattern.test()
