The Project | About Us | Contribute | Donations | License

HOME

The Bridge pattern is a structural design pattern that decouples an abstraction from its implementation so that the two can vary independently. This pattern is particularly useful when both the abstractions and their implementations are likely to change frequently.

Key Concepts

Abstraction: The high-level control layer for some entity. This layer is not concerned with the implementation details.
Implementor: The low-level layer that provides the actual implementation of the abstraction.
Refined Abstraction: A variant of the abstraction that adds additional features.
Concrete Implementor: A specific implementation of the implementor interface.

Structure

The Bridge pattern involves four main components:

Abstraction: Defines the abstraction's interface and maintains a reference to an object of type Implementor.
Refined Abstraction: Extends the interface defined by Abstraction.
Implementor: Defines the interface for implementation classes.
Concrete Implementor: Implements the Implementor interface.

Here's a UML diagram to illustrate the structure:

Abstraction
    + operation()
    - implementor: Implementor

RefinedAbstraction
    + operation()

Implementor
    + operationImpl()

ConcreteImplementorA
    + operationImpl()

ConcreteImplementorB
    + operationImpl()

Example

Let's consider an example where we have different types of remote controls (Abstraction) for different types of devices (Implementor).

Code Example

# Implementor Interface
class Device:
    def turn_on(self):
        pass

    def turn_off(self):
        pass

# Concrete Implementor 1
class TV(Device):
    def turn_on(self):
        print("TV is turned on")

    def turn_off(self):
        print("TV is turned off")

# Concrete Implementor 2
class Radio(Device):
    def turn_on(self):
        print("Radio is turned on")

    def turn_off(self):
        print("Radio is turned off")

# Abstraction
class RemoteControl:
    def __init__(self, device: Device):
        self.device = device

    def turn_on(self):
        self.device.turn_on()

    def turn_off(self):
        self.device.turn_off()

# Refined Abstraction
class AdvancedRemoteControl(RemoteControl):
    def mute(self):
        print("Device is muted")

# Client code
tv = TV()
radio = Radio()

remote = RemoteControl(tv)
remote.turn_on()
remote.turn_off()

advanced_remote = AdvancedRemoteControl(radio)
advanced_remote.turn_on()
advanced_remote.mute()
advanced_remote.turn_off()

Explanation

Device: The Device class is the Implementor interface that declares methods turn_on and turn_off.
TV and Radio: These are Concrete Implementors that provide specific implementations for the Device interface.
RemoteControl: This is the Abstraction that maintains a reference to a Device object and delegates the turn_on and turn_off operations to it.
AdvancedRemoteControl: This is a Refined Abstraction that extends the functionality of RemoteControl by adding a mute method.

Practical Exercises

Exercise 1: Implement a New Device

Task: Implement a new device class SmartLight that can be controlled by the RemoteControl.

class SmartLight(Device):
    def turn_on(self):
        print("SmartLight is turned on")

    def turn_off(self):
        print("SmartLight is turned off")

# Test your implementation
smart_light = SmartLight()
remote = RemoteControl(smart_light)
remote.turn_on()
remote.turn_off()

Solution:

class SmartLight(Device):
    def turn_on(self):
        print("SmartLight is turned on")

    def turn_off(self):
        print("SmartLight is turned off")

# Test your implementation
smart_light = SmartLight()
remote = RemoteControl(smart_light)
remote.turn_on()
remote.turn_off()

Exercise 2: Extend the Remote Control

Task: Extend the AdvancedRemoteControl to include a volume_up and volume_down method.

class AdvancedRemoteControl(RemoteControl):
    def mute(self):
        print("Device is muted")
    
    def volume_up(self):
        print("Volume is increased")
    
    def volume_down(self):
        print("Volume is decreased")

# Test your implementation
advanced_remote = AdvancedRemoteControl(tv)
advanced_remote.turn_on()
advanced_remote.volume_up()
advanced_remote.volume_down()
advanced_remote.turn_off()

Solution:

class AdvancedRemoteControl(RemoteControl):
    def mute(self):
        print("Device is muted")
    
    def volume_up(self):
        print("Volume is increased")
    
    def volume_down(self):
        print("Volume is decreased")

# Test your implementation
advanced_remote = AdvancedRemoteControl(tv)
advanced_remote.turn_on()
advanced_remote.volume_up()
advanced_remote.volume_down()
advanced_remote.turn_off()

Common Mistakes and Tips

Confusing Abstraction and Implementor: Ensure that the Abstraction only defines high-level operations and delegates the actual work to the Implementor.
Overcomplicating the Design: Start simple and only introduce the Bridge pattern when you see a clear need for decoupling abstraction from implementation.
Not Leveraging Polymorphism: Make sure to use polymorphism effectively to allow different implementations to be interchangeable.

Conclusion

The Bridge pattern is a powerful tool for decoupling abstraction from implementation, allowing both to vary independently. By understanding and applying this pattern, you can create flexible and maintainable code that can adapt to changing requirements. In the next section, we will explore another structural pattern: the Composite pattern.

Bridge

Key Concepts

Structure

Example

Code Example

Explanation

Practical Exercises

Exercise 1: Implement a New Device

Exercise 2: Extend the Remote Control

Common Mistakes and Tips

Conclusion

Software Design Patterns Course

Module 1: Introduction to Design Patterns

Module 2: Creational Patterns

Module 3: Structural Patterns

Module 4: Behavioral Patterns

Module 5: Application of Design Patterns

Module 6: Advanced Design Patterns

Module 7: Additional Resources and Conclusion