Bridge

The Bridge design pattern is a structural pattern that decouples an abstraction from its implementation so that the two can vary independently. This pattern is useful when you want to avoid a permanent binding between an abstraction and its implementation.

Imagine you have a remote control that can turn on and off different devices, such as a TV or a radio. The Bridge pattern allows you to separate the remote control from the devices it controls, so you can add new devices without changing the remote control.

Key Concepts

1. Abstraction: The high-level control layer for some entity.

2. Implementor: The low-level layer that performs the actual work.

3. Concrete Implementor: A specific implementation of the Implementor interface.

4. Refined Abstraction: Extends the interface defined by Abstraction.

Benefits

1. Decoupling Abstraction and Implementation: It separates the abstraction from its implementation, allowing both to vary independently. This makes the code more flexible and easier to maintain.

2. Improved Extensibility: You can extend both the abstraction and the implementation hierarchies independently without affecting each other. This makes it easier to introduce new abstractions and implementations.

3. Enhanced Modularity: By separating concerns, the Bridge pattern promotes a cleaner and more modular codebase. Each class has a single responsibility, adhering to the Single Responsibility Principle.

4. Reduced Code Duplication: Common code can be placed in the abstraction, while specific implementations can be handled by the implementor classes. This reduces redundancy and promotes code reuse.

5. Increased Flexibility: The pattern allows you to switch implementations at runtime, providing greater flexibility in how objects are used and interact.

6. Simplified Testing: Decoupling makes it easier to test components in isolation. You can mock or stub implementations when testing the abstraction, and vice versa.

These benefits make the Bridge pattern a powerful tool for managing complexity in large and evolving codebases. UML Diagram ———–

+-------------------+          +----------------------+
|     Abstraction   |          |     Implementor      |
+-------------------+          +----------------------+
| - implementor:    |<>------->| + operationImpl()    |
|   Implementor     |          +----------------------+
| + operation()     |          |                      |
+-------------------+          +----------------------+
        / \                             / \
       /   \                           /   \
      /     \                         /     \
+-------------------+          +----------------------+
|Refined Abstraction|          | Concrete Implementor |
+-------------------+          +----------------------+
| + operation()     |          | + operationImpl()    |
+-------------------+          +----------------------+

--- Java Example ---

 // Implementor interface
 public interface Implementor {
     void operationImpl();
 }

 // Concrete Implementor A
 public class ConcreteImplementorA implements Implementor {
     @Override
     public void operationImpl() {
         System.out.println("ConcreteImplementorA: operationImpl");
     }
 }

 // Concrete Implementor B
 public class ConcreteImplementorB implements Implementor {
     @Override
     public void operationImpl() {
         System.out.println("ConcreteImplementorB: operationImpl");
     }
 }

 // Abstraction
 public abstract class Abstraction {
     protected Implementor implementor;

     protected Abstraction(Implementor implementor) {
         this.implementor = implementor;
     }

     public abstract void operation();
 }

 // Refined Abstraction
 public class RefinedAbstraction extends Abstraction {
     public RefinedAbstraction(Implementor implementor) {
         super(implementor);
     }

     @Override
     public void operation() {
         implementor.operationImpl();
     }
 }

 // Client code
 public class Client {
     public static void main(String[] args) {
         Implementor implementorA = new ConcreteImplementorA();
         Abstraction abstractionA = new RefinedAbstraction(implementorA);
         abstractionA.operation();

         Implementor implementorB = new ConcreteImplementorB();
         Abstraction abstractionB = new RefinedAbstraction(implementorB);
         abstractionB.operation();
     }
 }

--- Python Example ---

 from abc import ABC, abstractmethod
 from typing import Protocol

 # Implementor interface
 class Implementor(Protocol):
     def operation_impl(self) -> None:
         pass

 # Concrete Implementor A
 class ConcreteImplementorA:
     def operation_impl(self) -> None:
         print("ConcreteImplementorA: operation_impl")

 # Concrete Implementor B
 class ConcreteImplementorB:
     def operation_impl(self) -> None:
         print("ConcreteImplementorB: operation_impl")

 # Abstraction
 class Abstraction(ABC):
     def __init__(self, implementor: Implementor) -> None:
         self._implementor = implementor

     @abstractmethod
     def operation(self) -> None:
         pass

 # Refined Abstraction
 class RefinedAbstraction(Abstraction):
     def operation(self) -> None:
         self._implementor.operation_impl()

 # Client code
 if __name__ == "__main__":
     implementor_a = ConcreteImplementorA()
     abstraction_a = RefinedAbstraction(implementor_a)
     abstraction_a.operation()

     implementor_b = ConcreteImplementorB()
     abstraction_b = RefinedAbstraction(implementor_b)
     abstraction_b.operation()