Bridge pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the abstraction class with a bridge to the implementation.

LLD

class Abstraction:
    def __init__(self, [1]):
        self.implementation = implementation

Drag options to blanks, or click blank then click option'

Aimplementation

Bbridge

Cimpl

Dinterface

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name that does not match the attribute.

Forgetting to assign the parameter to an attribute.

The abstraction class holds a reference to the implementation object, usually named implementation.

2fill in blank

medium

Complete the code to define the implementation interface method.

LLD

class Implementation:
    def [1](self):
        pass

Drag options to blanks, or click blank then click option'

Arun

Bimplement

Cexecute

Doperation

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that are too specific or unrelated.

Forgetting to define the method at all.

The implementation interface defines the operation method that concrete implementations must override.

3fill in blank

hard

Fix the error in the refined abstraction method calling the implementation.

LLD

class RefinedAbstraction(Abstraction):
    def operation(self):
        return self.[1].operation()

Drag options to blanks, or click blank then click option'

Abridge

Bimpl

Cimplementation

Dinterface

Attempts:

3 left

💡 Hint

Common Mistakes

Using an incorrect attribute name that does not exist.

Calling the method on the abstraction itself instead of the implementation.

The refined abstraction calls the operation method on the implementation attribute.

4fill in blank

hard

Fill both blanks to complete the concrete implementation class and its operation method.

LLD

class ConcreteImplementation[1](Implementation):
    def operation(self):
        return '[2] implementation result'

Drag options to blanks, or click blank then click option'

AA

BB

CConcrete

DSample

Attempts:

3 left

💡 Hint

Common Mistakes

Using a class name that does not match the pattern.

Returning a string that does not describe the implementation.

The concrete implementation class is named ConcreteImplementationA and returns a string indicating its result.

5fill in blank

hard

Fill all three blanks to create a client code that uses the bridge pattern.

LLD

impl = ConcreteImplementation[1]()
abstraction = RefinedAbstraction([2])
result = abstraction.[3]()
print(result)

Drag options to blanks, or click blank then click option'

AB

Bimpl

Coperation

DA

Attempts:

3 left

💡 Hint

Common Mistakes

Using mismatched implementation suffix and class name.

Passing wrong variable to the abstraction constructor.

Calling a method that does not exist.

The client creates a ConcreteImplementationA instance, passes it to RefinedAbstraction, calls operation, and prints the result.

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