Bridge pattern

src: i.ytimg.com

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. 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. In fact, the bridge pattern 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.

Video Bridge pattern

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.

What problems can the Bridge design pattern solve?

• 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 can't 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 UML class and sequence diagram below.

Maps Bridge pattern

Structure

UML class and sequence diagram

In the above UML class diagram, an abstraction (Abstraction) isn't implemeted 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

src: previews.123rf.com

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

As you can see, the Bridge classes are the Implementation that uses the same interface-oriented architecture to create objects. On the other hand, the abstraction takes an object of the implementation phase and runs its method. Thus, it makes completely decoupled from one another.

Crystal

Output

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

Java

The following Java (SE 6) program illustrates a 'shape'.

It will output:

  API1.circle at 1.000000:2.000000 radius 3.075000  API2.circle at 5.000000:7.000000 radius 11.275000  

PHP

Output:

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

Scala

Python

src: 3.bp.blogspot.com

See also

• Adapter pattern
• Strategy pattern
• Template method pattern

src: 2.bp.blogspot.com

References

src: s-media-cache-ak0.pinimg.com

External links

• Bridge in UML and in LePUS3 (a formal modelling language)
• "C# Design Patterns: The Bridge Pattern". Sample Chapter.  From: James W. Cooper. C# Design Patterns: A Tutorial. Addison-Wesley. ISBN 0-201-84453-2. 

Source of the article : Wikipedia