The Bridge Pattern

the intent of the Bridge pattern is to "De-couple an abstraction from its implementation so that the two can vary independently."

The Bridge pattern separates variations in abstraction and implementation to solve the class explosion problem.

Using design patterns will help you move along this learning curve more quickly. It involves a transition from using a different specialization for each variation (inheritance) to moving these variations into used or owned objects (composition).

Commonality analysis is the search for common elements that helps us understand how family members are the same.Variability analysis reveals how family members vary. Variability only makes sense within a given commonality. The common concepts will be represented by abstract classes. The variations found by variability analysis will be implemented by the concrete classes

There are two basic strategies to follow in creating designs to deal with the variations:

• Find what varies and encapsulate it.

• Favor composition over inheritance.

In the past, developers often relied on extensive inheritance trees to coordinate these variations. However, the second strategy says to try composition when possible. The intent of this is to be able to contain the variations in independent classes, thereby allowing for future variations without affecting the code. One way to do this is to have each variation contained in its own abstract class and then see how the abstract classes relate to each other.

 

The Bridge Pattern: Key Features Intent Decouple a set of implementations from the set of objects using them. Problem The derivations of an abstract class must use multiple implementations without causing an explosion in the number of classes. Solution Define an interface for all implementations to use and have the derivations of the abstract class use that. Participants and Collaborators The Abstraction defines the interface for the objects being implemented. The Implementor defines the interface for the specific implementation classes. Classes derived from the Abstraction use classes derived from the Implementor without knowing which particular ConcreteImplementor is in use. Consequences The decoupling of the implementations from the objects that use them increases extensibility. Client objects are not aware of implementation issues. Implementation Encapsulate the implementations in an abstract class. Contain a handle to it in the base class of the abstraction being implemented. Note: In Java, you can use interfaces instead of an abstract class for the implementation.

 

note : the abstraction and implementation are not the same as the abstract class and the implemented class.