Bridge pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the purpose of the Bridge pattern

Which of the following best describes the main purpose of the Bridge pattern in software design?

A To combine multiple interfaces into a single interface

B To provide a simplified interface to a complex subsystem

C To restrict object creation to a single instance

D To separate an abstraction from its implementation so they can vary independently

💡 Hint

Think about how the Bridge pattern helps manage changes in code.

The Bridge pattern decouples abstraction from implementation, allowing both to change independently without affecting each other.

❓ Architecture

intermediate

Identifying components in a Bridge pattern diagram

In a Bridge pattern architecture, which two components are connected by the bridge?

A Abstraction and Implementor

B Client and ConcreteImplementor

C Abstraction and Client

D ConcreteAbstraction and ConcreteImplementor

💡 Hint

One component defines the interface, the other provides the implementation.

The Abstraction defines the high-level control, and the Implementor defines the low-level implementation. The bridge connects these two.

❓ scaling

advanced

Scaling a system using the Bridge pattern

You have a graphics rendering system with multiple shapes and multiple rendering APIs. How does the Bridge pattern help scale this system?

A By enforcing a strict one-to-one mapping between shapes and rendering APIs

B By allowing shapes and rendering APIs to be extended independently without modifying existing code

C By duplicating code for each shape and rendering API combination

D By merging all shapes and rendering APIs into a single class to reduce complexity

💡 Hint

Consider how independent extension helps when adding new shapes or APIs.

The Bridge pattern allows shapes (abstractions) and rendering APIs (implementations) to evolve separately, making the system scalable and maintainable.

❓ tradeoff

advanced

Tradeoffs when using the Bridge pattern

What is a common tradeoff when applying the Bridge pattern in system design?

A Tight coupling between abstraction and implementation

B Reduced flexibility in changing implementations

C Increased complexity due to more classes and interfaces

D Difficulty in adding new abstractions

💡 Hint

Think about what happens when you add layers of abstraction.

The Bridge pattern introduces additional classes and interfaces, which can increase system complexity, but this tradeoff is balanced by improved flexibility.

❓ component

expert

Request flow in a Bridge pattern implementation

Consider a Bridge pattern where Abstraction calls methods on Implementor. Which sequence correctly describes the request flow when a client calls an operation on the Abstraction?

A Client → Abstraction → Implementor → ConcreteImplementor

B Client → Implementor → Abstraction → ConcreteImplementor

C Client → ConcreteImplementor → Implementor → Abstraction

D Client → ConcreteImplementor → Abstraction → Implementor

💡 Hint

Remember the Abstraction delegates work to the Implementor.

The client calls the Abstraction, which delegates to the Implementor interface, which is implemented by ConcreteImplementor.

Practice

1. What is the main purpose of the Bridge pattern in system design?

easy

A. To create a single class that handles all functionalities

B. To separate an abstraction from its implementation so they can vary independently

C. To enforce a strict inheritance hierarchy without flexibility

D. To combine multiple unrelated classes into one

Solution

1. Step 1: Understand the Bridge pattern concept

   The Bridge pattern is designed to separate an abstraction from its implementation, allowing both to change independently.

2. Step 2: Compare options with the concept

   To separate an abstraction from its implementation so they can vary independently correctly states this separation. Other options describe different or incorrect design approaches.

3. Final Answer:

   To separate an abstraction from its implementation so they can vary independently -> Option B

4. Quick Check:

   Bridge pattern = separation of abstraction and implementation [OK]

Hint: Bridge = separate interface and implementation [OK]

Common Mistakes:

• Confusing Bridge with Adapter or Decorator patterns
• Thinking Bridge merges classes instead of separating
• Assuming Bridge enforces rigid inheritance

2. Which of the following is the correct way to define the Bridge pattern structure in code?

easy

A. class Implementor extends Abstraction {}

B. class Abstraction extends Implementor {}

C. class Abstraction { Implementor impl; }

D. class Abstraction implements Implementor {}

Solution

1. Step 1: Recall Bridge pattern structure

   Bridge pattern uses composition: the abstraction holds a reference to the implementor interface.

2. Step 2: Analyze each option

   class Abstraction { Implementor impl; } correctly shows the required composition. The other options use inheritance (extends) or interface implementation (implements), which defeats the purpose of decoupling via composition.

3. Final Answer:

   class Abstraction { Implementor impl; } -> Option C

4. Quick Check:

   Bridge uses composition, not inheritance [OK]

Hint: Bridge uses composition, not inheritance [OK]

Common Mistakes:

• Using inheritance instead of composition
• Confusing implements keyword with composition
• Ignoring the implementor interface role

3. Given the following code snippet using the Bridge pattern, what will be the output?

class DrawingAPI {
  drawCircle(x, y, radius) { console.log(`API drawing circle at (${x},${y}) with radius ${radius}`); }
}

class Shape {
  constructor(drawingAPI) { this.drawingAPI = drawingAPI; }
  draw() {}
}

class Circle extends Shape {
  constructor(x, y, radius, drawingAPI) {
    super(drawingAPI);
    this.x = x; this.y = y; this.radius = radius;
  }
  draw() {
    this.drawingAPI.drawCircle(this.x, this.y, this.radius);
  }
}

const api = new DrawingAPI();
const circle = new Circle(5, 10, 7, api);
circle.draw();

medium

A. API drawing circle at (5,10) with radius 7

B. Circle drawn at (5,10) with radius 7

C. Error: drawCircle is not a function

D. No output

Solution

1. Step 1: Trace the draw() method call

   The Circle's draw method calls drawingAPI.drawCircle with x=5, y=10, radius=7.

2. Step 2: Check DrawingAPI's drawCircle implementation

   It logs: "API drawing circle at (5,10) with radius 7" to the console.

3. Final Answer:

   API drawing circle at (5,10) with radius 7 -> Option A

4. Quick Check:

   drawCircle logs correct message [OK]

Hint: Follow method calls and parameters carefully [OK]

Common Mistakes:

• Assuming drawCircle is undefined
• Confusing output message text
• Ignoring parameter values passed

4. Identify the error in the following Bridge pattern implementation:

class Implementor {
  operation() { console.log('Implementor operation'); }
}

class Abstraction {
  constructor() { this.impl = new Implementor(); }
  operation() { this.impl.operation(); }
}

const abs = new Abstraction();
abs.operation();

medium

A. Abstraction should not create Implementor instance directly

B. Implementor should be an interface or abstract class, not a concrete class

C. operation method should return a value

D. No error, code works fine

Solution

1. Step 1: Review Bridge pattern best practice

   Abstraction should receive Implementor via constructor injection, not create it internally, to allow flexibility.

2. Step 2: Analyze code's constructor

   Abstraction creates Implementor directly, which tightly couples them and breaks Bridge pattern intent.

3. Final Answer:

   Abstraction should not create Implementor instance directly -> Option A

4. Quick Check:

   Bridge needs abstraction to hold implementor, not create it [OK]

Hint: Inject implementor, don't instantiate inside abstraction [OK]

Common Mistakes:

• Ignoring tight coupling caused by direct instantiation
• Thinking concrete class Implementor is always wrong
• Expecting operation to return value unnecessarily

5. You are designing a graphics system that supports multiple shapes (Circle, Square) and multiple rendering APIs (OpenGL, DirectX). How does the Bridge pattern help in this design?

hard

A. By using inheritance to create a subclass for each shape-API combination

B. By forcing all shapes to use a single rendering API implementation

C. By merging shape and rendering API classes into one large class

D. By allowing shapes and rendering APIs to vary independently without subclass explosion

Solution

1. Step 1: Understand the problem of subclass explosion

   If each shape-API pair requires a subclass, the number grows quickly (e.g., CircleOpenGL, CircleDirectX).

2. Step 2: Apply Bridge pattern advantage

   Bridge separates shape abstraction from rendering implementation, so shapes and APIs can be combined dynamically without many subclasses.

3. Final Answer:

   By allowing shapes and rendering APIs to vary independently without subclass explosion -> Option D

4. Quick Check:

   Bridge reduces subclass explosion by separating abstraction and implementation [OK]

Hint: Bridge avoids subclass explosion by separating concerns [OK]

Common Mistakes:

• Thinking Bridge merges classes instead of separating
• Assuming inheritance must handle all combinations
• Ignoring dynamic combination of abstraction and implementation