Bridge pattern

Overview

The Bridge pattern separates an abstraction from its implementation so both can vary independently. Instead of a class hierarchy with every combination (EmailAlert, SmsAlert, UrgentEmailAlert, UrgentSmsAlert...), you have an abstraction hierarchy (Alert, UrgentAlert) that holds a reference to an implementation hierarchy (Channel: Email, SMS).

Bridge prevents the 'm x n' class explosion when two dimensions vary. It looks structurally like Strategy (composition with an interface), but the intent differs: Bridge is designed up front to decouple two orthogonal hierarchies that both evolve.

When to use it

• Two independent dimensions of variation (shape x renderer, message type x channel).
• Implementations should be switchable at runtime.
• You want to avoid a combinatorial subclass explosion.

Where it shows up in interviews

Where it is used in real software

Key terms

Abstraction

High-level control layer (Alert, Shape).

Refined abstraction

Variants of the abstraction (UrgentAlert).

Implementor

Low-level interface (Channel, Renderer).

Concrete implementor

EmailChannel, SvgRenderer.

How it works, step by step

1. 1
   Identify the two dimensions

   What varies independently?

2. 2
   Define the implementor interface

   Primitive operations: send(to, text).

3. 3
   Define the abstraction holding an implementor

   Alert(channel).

4. 4
   Extend each side independently

   New alert types; new channels.

5. 5
   Combine at runtime

   new UrgentAlert(new SmsChannel()).

Class count comparison

3 alert types x 4 channels

Bridge turns multiplication into addition.

Implementation

1// Implementor2interface Channel { send(to: string, text: string): void }3class EmailChannel implements Channel { send(to: string, t: string) { console.log("email", to, t); } }4class SmsChannel implements Channel { send(to: string, t: string) { console.log("sms", to, t.slice(0, 160)); } }5 6// Abstraction7abstract class Alert {8  constructor(protected channel: Channel) {}9  abstract notify(to: string, message: string): void;10}11 12class InfoAlert extends Alert {13  notify(to: string, message: string) { this.channel.send(to, message); }14}15 16class UrgentAlert extends Alert {17  notify(to: string, message: string) {18    this.channel.send(to, `URGENT: ${message}`);19    this.channel.send(to, `Reminder: ${message}`); // urgent policy: send twice20  }21}22 23new UrgentAlert(new SmsChannel()).notify("+15550100", "Server down");24new InfoAlert(new EmailChannel()).notify("[email protected]", "Deploy complete");

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Using Bridge with only one dimension.

  Fix: A single interface (Strategy) is enough.

• Leaking implementor details into abstractions.

  Fix: Keep implementors to primitive operations.

Interview questions

Practice problems