Bridge Design Pattern - GeeksforGeeks

22 Nov, 2021
The Bridge design pattern allows you to separate the abstraction from the implementation. It is a structural design pattern. 
There are 2 parts in Bridge design pattern : 
AbstractionImplementation
Abstraction
Implementation
This is a design mechanism that encapsulates an implementation class inside of an interface class.  
The bridge pattern allows the Abstraction and the Implementation to be developed independently and the client code can access only the Abstraction part without being concerned about the Implementation part.
The abstraction is an interface or abstract class and the implementer is also an interface or abstract class.
The abstraction contains a reference to the implementer. Children of the abstraction are referred to as refined abstractions, and children of the implementer are concrete implementers. Since we can change the reference to the implementer in the abstraction, we are able to change the abstraction’s implementer at run-time. Changes to the implementer do not affect client code.
It increases the loose coupling between class abstraction and it’s implementation.
UML Diagram of Bridge Design Pattern
Elements of Bridge Design Pattern 
Abstraction – core of the bridge design pattern and defines the crux. Contains a reference to the implementer.
Refined Abstraction – Extends the abstraction takes the finer detail one level below. Hides the finer elements from implemetors.
Implementer – It defines the interface for implementation classes. This interface does not need to correspond directly to the abstraction interface and can be very different. Abstraction imp provides an implementation in terms of operations provided by the Implementer interface.
Concrete Implementation – Implements the above implementer by providing the concrete implementation.
Lets see an Example of Bridge Design Pattern :  
Java
// Java code to demonstrate// bridge design pattern // abstraction in bridge patternabstract class Vehicle {    protected Workshop workShop1;    protected Workshop workShop2;     protected Vehicle(Workshop workShop1, Workshop workShop2)    {        this.workShop1 = workShop1;        this.workShop2 = workShop2;    }     abstract public void manufacture();} // Refine abstraction 1 in bridge patternclass Car extends Vehicle {    public Car(Workshop workShop1, Workshop workShop2)    {        super(workShop1, workShop2);    }     @Override    public void manufacture()    {        System.out.print("Car ");        workShop1.work();        workShop2.work();    }} // Refine abstraction 2 in bridge patternclass Bike extends Vehicle {    public Bike(Workshop workShop1, Workshop workShop2)    {        super(workShop1, workShop2);    }     @Override    public void manufacture()    {        System.out.print("Bike ");        workShop1.work();        workShop2.work();    }} // Implementor for bridge patterninterface Workshop{    abstract public void work();} // Concrete implementation 1 for bridge patternclass Produce implements Workshop {    @Override    public void work()    {        System.out.print("Produced");    }} // Concrete implementation 2 for bridge patternclass Assemble implements Workshop {    @Override    public void work()    {        System.out.print(" And");        System.out.println(" Assembled.");    }} // Demonstration of bridge design patternclass BridgePattern {    public static void main(String[] args)    {        Vehicle vehicle1 = new Car(new Produce(), new Assemble());        vehicle1.manufacture();        Vehicle vehicle2 = new Bike(new Produce(), new Assemble());        vehicle2.manufacture();    }}
Output : 
Car Produced And Assembled.
Bike Produced And Assembled.
Here we’re producing and assembling the two different vehicles using Bridge design pattern. 
When we need bridge design pattern
The Bridge pattern is an application of the old advice, “prefer composition over inheritance”. It becomes handy when you must subclass different times in ways that are orthogonal with one another.For Example, the above example can also be done something like this : 
Without Bridge Design Pattern 
But the above solution has a problem. If you want to change the Bus class, then you may end up changing ProduceBus and AssembleBus as well and if the change is workshop specific then you may need to change the Bike class as well.
With Bridge Design Pattern
You can solve the above problem by decoupling the Vehicle and Workshop interfaces in the below manner.
Advantages 
Bridge pattern decouple an abstraction from its implementation so that the two can vary independently.It is used mainly for implementing platform independence features.It adds one more method level redirection to achieve the objective.Publish abstraction interface in a separate inheritance hierarchy, and put the implementation in its own inheritance hierarchy.Use bridge pattern to run-time binding of the implementation.Use bridge pattern to map orthogonal class hierarchiesBridge is designed up-front to let the abstraction and the implementation vary independently.
Bridge pattern decouple an abstraction from its implementation so that the two can vary independently.
It is used mainly for implementing platform independence features.
It adds one more method level redirection to achieve the objective.
Publish abstraction interface in a separate inheritance hierarchy, and put the implementation in its own inheritance hierarchy.
Use bridge pattern to run-time binding of the implementation.
Use bridge pattern to map orthogonal class hierarchies
Bridge is designed up-front to let the abstraction and the implementation vary independently.
Further Read: Bridge Method in Python
This article is contributed by Saket Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
sunny94
Nistelrooy
srnathan711
Design Pattern
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Command Pattern
Strategy Pattern | Set 1 (Introduction)
Template Method Design Pattern
State Design Pattern
Difference between Sequence Diagram and Activity Diagram
Visitor design pattern
Iterator Pattern
Observer Pattern | Set 2 (Implementation)
Difference between Sequence diagram and Collaboration diagram
Difference Between Architectural Style, Architectural Patterns and Design Patterns