{"title":"Bridge Design Pattern","description":null,"content":"\n\n\n\n\n> **DEFINITION**\n>\n> The **Bridge Design Pattern** is a **structural pattern** that lets you **decouple an abstraction from its implementation**, allowing the two to vary **independently**.\n\n\nIt’s particularly useful in situations where:\n\n- You have classes that can be extended in **multiple orthogonal dimensions** (e.g., shape vs. rendering technology, UI control vs. platform).\n- You want to avoid a deep inheritance hierarchy that **multiplies combinations** of features.\n- You need to **combine multiple variations of behavior or implementation at runtime**.\n\nThe **Bridge Pattern** splits a class into two separate hierarchies:\n\n- One for the **abstraction** (e.g., shape, UI control)\n- One for the **implementation** (e.g., rendering engine, platform)\n\nThese two hierarchies are **\"bridged\"** via composition (not inheritance) allowing you to mix and match independently.\n\nLet’s walk through a real-world example to see how we can apply the Bridge Pattern to build a system that is both **flexible and scalable**, without being buried under layers of rigid subclasses.\n\n---\n\n# 1. The Problem: Drawing Shapes\n\nImagine you're building a **cross-platform graphics library**. It supports rendering **shapes** like circles and rectangles using different rendering approaches:\n\n- 🟢 **Vector rendering:** for scalable, resolution-independent output\n- 🔵 **Raster rendering:** for pixel-based output\n\nNow, you need to support:\n\n- Drawing **different shapes** (e.g., `Circle`, `Rectangle`)\n- Using **different renderers** (e.g., `VectorRenderer`, `RasterRenderer`)\n\n### Naive Implementation: Subclass for Every Combination\n\nYou might start by creating a class hierarchy that looks like this:\n\n\n```java\nabstract class Shape {\n public abstract void draw();\n}\n\n// Circle variants\nclass VectorCircle extends Shape {\n public void draw() {\n System.out.println(\"Drawing Circle as VECTORS\");\n }\n}\n\nclass RasterCircle extends Shape {\n public void draw() {\n System.out.println(\"Drawing Circle as PIXELS\");\n }\n}\n\n// Rectangle variants\nclass VectorRectangle extends Shape {\n public void draw() {\n System.out.println(\"Drawing Rectangle as VECTORS\");\n }\n}\n\nclass RasterRectangle extends Shape {\n public void draw() {\n System.out.println(\"Drawing Rectangle as PIXELS\");\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass Shape(ABC):\n @abstractmethod\n def draw(self):\n pass\n\n# Circle variants\nclass VectorCircle(Shape):\n def draw(self):\n print(\"Drawing Circle as VECTORS\")\n\nclass RasterCircle(Shape):\n def draw(self):\n print(\"Drawing Circle as PIXELS\")\n\n# Rectangle variants\nclass VectorRectangle(Shape):\n def draw(self):\n print(\"Drawing Rectangle as VECTORS\")\n\nclass RasterRectangle(Shape):\n def draw(self):\n print(\"Drawing Rectangle as PIXELS\")\n```\n\n```cpp\n#include \nusing namespace std;\n\nclass Shape {\npublic:\n virtual ~Shape() {}\n virtual void draw() = 0;\n};\n\n// Circle variants\nclass VectorCircle : public Shape {\npublic:\n void draw() override {\n cout << \"Drawing Circle as VECTORS\" << endl;\n }\n};\n\nclass RasterCircle : public Shape {\npublic:\n void draw() override {\n cout << \"Drawing Circle as PIXELS\" << endl;\n }\n};\n\n// Rectangle variants\nclass VectorRectangle : public Shape {\npublic:\n void draw() override {\n cout << \"Drawing Rectangle as VECTORS\" << endl;\n }\n};\n\nclass RasterRectangle : public Shape {\npublic:\n void draw() override {\n cout << \"Drawing Rectangle as PIXELS\" << endl;\n }\n};\n```\n\n```go\ntype Shape interface {\n\tDraw()\n}\n\n// Circle variants\ntype VectorCircle struct{}\n\nfunc (VectorCircle) Draw() {\n\tprintln(\"Drawing Circle as VECTORS\")\n}\n\ntype RasterCircle struct{}\n\nfunc (RasterCircle) Draw() {\n\tprintln(\"Drawing Circle as PIXELS\")\n}\n\n// Rectangle variants\ntype VectorRectangle struct{}\n\nfunc (VectorRectangle) Draw() {\n\tprintln(\"Drawing Rectangle as VECTORS\")\n}\n\ntype RasterRectangle struct{}\n\nfunc (RasterRectangle) Draw() {\n\tprintln(\"Drawing Rectangle as PIXELS\")\n}\n```\n\n```csharp\nabstract class Shape\n{\n public abstract void Draw();\n}\n\n// Circle variants\nclass VectorCircle : Shape\n{\n public override void Draw()\n {\n Console.WriteLine(\"Drawing Circle as VECTORS\");\n }\n}\n\nclass RasterCircle : Shape\n{\n public override void Draw()\n {\n Console.WriteLine(\"Drawing Circle as PIXELS\");\n }\n}\n\n// Rectangle variants\nclass VectorRectangle : Shape\n{\n public override void Draw()\n {\n Console.WriteLine(\"Drawing Rectangle as VECTORS\");\n }\n}\n\nclass RasterRectangle : Shape\n{\n public override void Draw()\n {\n Console.WriteLine(\"Drawing Rectangle as PIXELS\");\n }\n}\n```\n\n```typescript\nabstract class Shape {\n public abstract draw(): void;\n}\n\n// Circle variants\nclass VectorCircle extends Shape {\n public draw(): void {\n console.log(\"Drawing Circle as VECTORS\");\n }\n}\n\nclass RasterCircle extends Shape {\n public draw(): void {\n console.log(\"Drawing Circle as PIXELS\");\n }\n}\n\n// Rectangle variants\nclass VectorRectangle extends Shape {\n public draw(): void {\n console.log(\"Drawing Rectangle as VECTORS\");\n }\n}\n\nclass RasterRectangle extends Shape {\n public draw(): void {\n console.log(\"Drawing Rectangle as PIXELS\");\n }\n}\n```\n\n\nHere is what this class hierarchy looks like:\n\n\n```mermaid\nclassDiagram\n class Shape {\n <>\n +draw()\n }\n\n class VectorCircle {\n +draw()\n }\n\n class RasterCircle {\n +draw()\n }\n\n class VectorRectangle {\n +draw()\n }\n\n class RasterRectangle {\n +draw()\n }\n\n Shape <|-- VectorCircle\n Shape <|-- RasterCircle\n Shape <|-- VectorRectangle\n Shape <|-- RasterRectangle\n\n style Shape fill:#38d9a9,stroke:#000,color:#000\n style VectorCircle fill:#ff8787,stroke:#000,color:#000\n style RasterCircle fill:#ff8787,stroke:#000,color:#000\n style VectorRectangle fill:#ff8787,stroke:#000,color:#000\n style RasterRectangle fill:#ff8787,stroke:#000,color:#000\n```\n\n\nEvery red node is a class that fuses two concerns: shape identity and rendering strategy. This is only 2 shapes and 2 renderers. The problem compounds quickly.\n\n### Why This Quickly Breaks Down\n\n#### 1. Class Explosion\n\nEvery new combination of shape and rendering method requires a **new subclass**:\n\n- 2 shapes × 2 renderers = 4 classes\n- Add a third renderer (e.g., OpenGL)? Now you need 6 classes\n- Add more shapes (e.g., triangle, ellipse)? The combinations multiply\n\nThis makes the class hierarchy **bloated and rigid**.\n\n#### 2. Tight Coupling\n\nEach class ties together shape logic and rendering logic. You cannot reuse rendering behavior independently of the shape. They are intertwined in every subclass.\n\n#### 3. Violates Open/Closed Principle\n\nIf you want to support a **new rendering engine**, you must modify or recreate every shape for that renderer.\n\n### What We Really Need\n\nWe need a solution that:\n\n- Separates the **abstraction** (`Shape`) from its **implementation** (`Renderer`)\n- Allows new renderers to be added without touching shape classes\n- Enables new shapes to be added without modifying or duplicating renderer logic\n- Keeps the system scalable, extensible, and composable\n\nThis is exactly where the **Bridge Pattern** comes in.\n\n---\n\n# 2. What is the Bridge Pattern\n\nThe **Bridge Design Pattern** lets you **split a class into two separate hierarchies: **one for the **abstraction** and another for the **implementation,** so that they can evolve independently.\n\nTwo characteristics define the pattern:\n\n1. **Independent variation:** The abstraction hierarchy (shapes) and the implementation hierarchy (renderers) can grow without affecting each other. Adding a new shape does not require touching any renderer. Adding a new renderer does not require touching any shape.\n2. **Composition over inheritance:** The abstraction holds a reference to an implementor object and delegates work to it at runtime, rather than inheriting implementation behavior. This keeps both hierarchies shallow and flexible.\n\n\n> **Real-World Analogy**\n>\n> Think of a TV remote control and the TV itself. The remote is the abstraction: it has buttons for power, volume, and channel. The TV is the implementation: it contains the circuits that actually change volume, switch channels, and toggle power. You can swap remotes without changing the TV, and you can swap TVs without changing the remote. \n>\n> A basic remote works with a Samsung TV. The same Samsung TV works with a universal remote that has extra buttons. The remote hierarchy and the TV hierarchy vary independently, connected only by the infrared signal between them. That signal is the bridge.\n\n\n---\n\n## Class Diagram\n\n\n\n\n\nThe structure involves four participants:\n\n#### 1. Abstraction (e.g., `Shape)`\n\nThe high-level interface that clients interact with. It defines operations in terms that make sense to the domain (e.g., \"draw a shape\") and delegates the low-level work to an implementor.\n\nIn our shapes example, `Shape` is the Abstraction. It holds a reference to a `Renderer` and declares a `draw()` method. The Shape knows what to draw, the Renderer knows how to draw it.\n\n#### 2. RefinedAbstraction (e.g., `Circle`, `Rectangle)`\n\nA concrete subclass of Abstraction that adds domain-specific state or behavior. It still delegates to the implementor for low-level operations.\n\nIn our example, `Circle` adds a `radius` field and passes it to the renderer when drawing. `Rectangle` adds `width` and `height`. Neither knows or cares whether the renderer uses vectors or pixels.\n\n#### 3. Implementor (e.g., `Renderer)`\n\nThe interface that defines the low-level operations that concrete implementations must provide. This is the \"other side\" of the bridge.\n\nIn our example, `Renderer` declares methods like `renderCircle(radius)` and `renderRectangle(width, height)`. These are primitive rendering operations that different engines implement differently.\n\n#### 4. ConcreteImplementors (e.g., `VectorRenderer,RasterRenderer)`\n\nA concrete class that implements the Implementor interface with a specific technology or strategy.\n\nIn our example, `VectorRenderer` outputs vector-based instructions and `RasterRenderer` outputs pixel-based instructions. Neither knows whether it is being called by a Circle or a Rectangle.\n\n---\n\n# 3. How It Works\n\nHere is the Bridge workflow, step by step:\n\n\n```mermaid\nsequenceDiagram\n participant Client\n participant Circle as Circle
(RefinedAbstraction)\n participant VR as VectorRenderer
(ConcreteImplementor)\n\n Client->>Circle: new Circle(vectorRenderer, 5)\n Client->>Circle: draw()\n Note over Circle: Delegates to implementor\n Circle->>VR: renderCircle(5)\n Note over VR: Renders circle using
vector graphics\n VR-->>Circle: done\n Circle-->>Client: done\n\n Note over Client,VR: The Circle does not know it is
using vectors. The VectorRenderer
does not know it is drawing a Circle.\n```\n\n\n#### **Step 1: Create a concrete implementor**\n\nThe client (or a factory) instantiates a specific implementation, for example `VectorRenderer`. This object knows how to perform low-level rendering operations using vector graphics.\n\n#### **Step 2: Pass it to the abstraction**\n\nThe client creates a `Circle` and passes the `VectorRenderer` into its constructor. The Circle stores this reference internally. It does not know or care what kind of renderer it received.\n\n#### **Step 3: Call the high-level operation**\n\nThe client calls `circle.draw()`. This is a domain-level operation: \"draw this shape.\" The client does not think about rendering engines.\n\n#### **Step 4: Abstraction delegates to implementor**\n\nInside `draw()`, the Circle calls `renderer.renderCircle(radius)`. It translates the high-level operation (\"draw me\") into a low-level operation (\"render a circle with this radius\") and delegates to the implementor.\n\n#### **Step 5: Implementor executes**\n\nThe `VectorRenderer` runs its own rendering logic, producing vector output. It has no idea it was called by a Circle. It just received a radius and did its job.\n\n---\n\n# 4. Implementing Bridge\n\nLet us now implement the Bridge pattern to decouple our Shape abstraction from the Renderer implementation. This allows us to mix and match shapes and rendering engines freely, without subclass explosion.\n\n### Step 1: Define the Implementor Interface (`Renderer`)\n\nThis interface declares rendering operations for shapes. Concrete implementations will define how to render shapes using a particular technique (vector, raster, etc.).\n\n\n```java\ninterface Renderer {\n void renderCircle(float radius);\n void renderRectangle(float width, float height);\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass Renderer(ABC):\n @abstractmethod\n def render_circle(self, radius: float):\n pass\n\n @abstractmethod\n def render_rectangle(self, width: float, height: float):\n pass\n```\n\n```cpp\nclass Renderer {\npublic:\n virtual ~Renderer() {}\n virtual void renderCircle(float radius) = 0;\n virtual void renderRectangle(float width, float height) = 0;\n};\n```\n\n```go\ntype Renderer interface {\n\tRenderCircle(radius float32)\n\tRenderRectangle(width, height float32)\n}\n```\n\n```csharp\ninterface IRenderer\n{\n void RenderCircle(float radius);\n void RenderRectangle(float width, float height);\n}\n```\n\n```typescript\ninterface Renderer {\n renderCircle(radius: number): void;\n renderRectangle(width: number, height: number): void;\n}\n```\n\n\n### Step 2: Create Concrete Implementations of the Renderer\n\nThese classes provide the actual rendering logic for each engine.\n\n#### 🟢 VectorRenderer\n\n\n```java\nclass VectorRenderer implements Renderer {\n @Override\n public void renderCircle(float radius) {\n System.out.println(\"Drawing a circle of radius \" + radius + \" using VECTOR rendering.\");\n }\n\n @Override\n public void renderRectangle(float width, float height) {\n System.out.println(\"Drawing a rectangle \" + width + \"x\" + height + \" using VECTOR rendering.\");\n }\n}\n```\n\n```python\nclass VectorRenderer(Renderer):\n def render_circle(self, radius):\n print(f\"Drawing a circle of radius {radius} using VECTOR rendering.\")\n \n def render_rectangle(self, width, height):\n print(f\"Drawing a rectangle {width}x{height} using VECTOR rendering.\")\n```\n\n```cpp\nclass VectorRenderer : public Renderer {\npublic:\n void renderCircle(float radius) override {\n cout << \"Drawing a circle of radius \" << radius << \" using VECTOR rendering.\" << endl;\n }\n\n void renderRectangle(float width, float height) override {\n cout << \"Drawing a rectangle \" << width << \"x\" << height << \" using VECTOR rendering.\" << endl;\n }\n};\n```\n\n```go\ntype VectorRenderer struct{}\n\nfunc (v *VectorRenderer) renderCircle(radius float32) {\n\tfmt.Println(\"Drawing a circle of radius\", radius, \"using VECTOR rendering.\")\n}\n\nfunc (v *VectorRenderer) renderRectangle(width, height float32) {\n\tfmt.Println(\"Drawing a rectangle\", width, \"x\", height, \"using VECTOR rendering.\")\n}\n```\n\n```csharp\nclass VectorRenderer : IRenderer\n{\n public void RenderCircle(float radius)\n {\n Console.WriteLine($\"Drawing a circle of radius {radius} using VECTOR rendering.\");\n }\n\n public void RenderRectangle(float width, float height)\n {\n Console.WriteLine($\"Drawing a rectangle {width}x{height} using VECTOR rendering.\");\n }\n}\n```\n\n```typescript\nclass VectorRenderer implements Renderer {\n renderCircle(radius: number): void {\n console.log(\"Drawing a circle of radius \" + radius + \" using VECTOR rendering.\");\n }\n\n renderRectangle(width: number, height: number): void {\n console.log(\"Drawing a rectangle \" + width + \"x\" + height + \" using VECTOR rendering.\");\n }\n}\n```\n\n\n#### 🔵 RasterRenderer\n\n\n```java\nclass RasterRenderer implements Renderer {\n @Override\n public void renderCircle(float radius) {\n System.out.println(\"Drawing pixels for a circle of radius \" + radius + \" (RASTER).\");\n }\n\n @Override\n public void renderRectangle(float width, float height) {\n System.out.println(\"Drawing pixels for a rectangle \" + width + \"x\" + height + \" (RASTER).\");\n }\n}\n```\n\n```python\nclass RasterRenderer(Renderer):\n def render_circle(self, radius):\n print(f\"Drawing pixels for a circle of radius {radius} (RASTER).\")\n \n def render_rectangle(self, width, height):\n print(f\"Drawing pixels for a rectangle {width}x{height} (RASTER).\")\n```\n\n```cpp\nclass RasterRenderer : public Renderer {\npublic:\n void renderCircle(float radius) override {\n cout << \"Drawing pixels for a circle of radius \" << radius << \" (RASTER).\" << endl;\n }\n\n void renderRectangle(float width, float height) override {\n cout << \"Drawing pixels for a rectangle \" << width << \"x\" << height << \" (RASTER).\" << endl;\n }\n};\n```\n\n```go\ntype RasterRenderer struct{}\n\nfunc (r *RasterRenderer) RenderCircle(radius float32) {\n\tfmt.Println(\"Drawing pixels for a circle of radius\", radius, \"(RASTER).\")\n}\n\nfunc (r *RasterRenderer) RenderRectangle(width, height float32) {\n\tfmt.Println(\"Drawing pixels for a rectangle\", width, \"x\", height, \"(RASTER).\")\n}\n```\n\n```csharp\nclass RasterRenderer : IRenderer\n{\n public void RenderCircle(float radius)\n {\n Console.WriteLine($\"Drawing pixels for a circle of radius {radius} (RASTER).\");\n }\n\n public void RenderRectangle(float width, float height)\n {\n Console.WriteLine($\"Drawing pixels for a rectangle {width}x{height} (RASTER).\");\n }\n}\n```\n\n```typescript\nclass RasterRenderer implements Renderer {\n renderCircle(radius: number): void {\n console.log(\"Drawing pixels for a circle of radius \" + radius + \" (RASTER).\");\n }\n\n renderRectangle(width: number, height: number): void {\n console.log(\"Drawing pixels for a rectangle \" + width + \"x\" + height + \" (RASTER).\");\n }\n}\n```\n\n\n### Step 3: Define the Abstraction (`Shape`)\n\nThis class holds a reference to the renderer and declares a general `draw()` method. Each concrete shape will implement `draw()` by delegating to the renderer.\n\n\n```java\nabstract class Shape {\n protected Renderer renderer;\n\n public Shape(Renderer renderer) {\n this.renderer = renderer;\n }\n\n public abstract void draw();\n}\n```\n\n```python\nclass Shape(ABC):\n def __init__(self, renderer):\n self.renderer = renderer\n \n @abstractmethod\n def draw(self):\n pass\n```\n\n```cpp\nclass Shape {\nprotected:\n Renderer* renderer;\n\npublic:\n Shape(Renderer* renderer) : renderer(renderer) {}\n virtual ~Shape() {}\n virtual void draw() = 0;\n};\n```\n\n```go\ntype Shape struct {\n\trenderer Renderer\n}\n\nfunc NewShape(renderer Renderer) Shape {\n\treturn Shape{renderer: renderer}\n}\n\nfunc (s Shape) draw() {\n}\n```\n\n```csharp\nabstract class Shape\n{\n protected IRenderer renderer;\n\n public Shape(IRenderer renderer)\n {\n this.renderer = renderer;\n }\n\n public abstract void Draw();\n}\n```\n\n```typescript\nabstract class Shape {\n protected renderer: Renderer;\n\n constructor(renderer: Renderer) {\n this.renderer = renderer;\n }\n\n public abstract draw(): void;\n}\n```\n\n\n### Step 4: Create Concrete Shapes\n\nEach shape delegates rendering to the renderer passed into it. The shape knows its own properties (radius, width, height), and the renderer knows how to draw primitives. Neither knows about the other's internals.\n\n#### Circle\n\n\n```java\nclass Circle extends Shape {\n private final float radius;\n\n public Circle(Renderer renderer, float radius) {\n super(renderer);\n this.radius = radius;\n }\n\n @Override\n public void draw() {\n renderer.renderCircle(radius);\n }\n}\n```\n\n```python\nclass Circle(Shape):\n def __init__(self, renderer, radius):\n super().__init__(renderer)\n self.radius = radius\n \n def draw(self):\n self.renderer.render_circle(self.radius)\n```\n\n```cpp\nclass Circle : public Shape {\nprivate:\n float radius;\n\npublic:\n Circle(Renderer* renderer, float radius) : Shape(renderer), radius(radius) {}\n\n void draw() override {\n renderer->renderCircle(radius);\n }\n};\n```\n\n```go\ntype Circle struct {\n\t*Shape\n\tradius float32\n}\n\nfunc NewCircle(renderer Renderer, radius float32) *Circle {\n\treturn &Circle{Shape: NewShape(renderer), radius: radius}\n}\n\nfunc (c *Circle) draw() {\n\tc.renderer.renderCircle(c.radius)\n}\n```\n\n```csharp\nclass Circle : Shape\n{\n private readonly float radius;\n\n public Circle(IRenderer renderer, float radius) : base(renderer)\n {\n this.radius = radius;\n }\n\n public override void Draw()\n {\n renderer.RenderCircle(radius);\n }\n}\n```\n\n```typescript\nclass Circle extends Shape {\n private readonly radius: number;\n\n constructor(renderer: Renderer, radius: number) {\n super(renderer);\n this.radius = radius;\n }\n\n draw(): void {\n this.renderer.renderCircle(this.radius);\n }\n}\n```\n\n\n#### Rectangle\n\n\n```java\nclass Rectangle extends Shape {\n private final float width;\n private final float height;\n\n public Rectangle(Renderer renderer, float width, float height) {\n super(renderer);\n this.width = width;\n this.height = height;\n }\n\n @Override\n public void draw() {\n renderer.renderRectangle(width, height);\n }\n}\n```\n\n```python\nclass Rectangle(Shape):\n def __init__(self, renderer, width, height):\n super().__init__(renderer)\n self.width = width\n self.height = height\n \n def draw(self):\n self.renderer.render_rectangle(self.width, self.height)\n```\n\n```cpp\nclass Rectangle : public Shape {\nprivate:\n float width;\n float height;\n\npublic:\n Rectangle(Renderer* renderer, float width, float height) \n : Shape(renderer), width(width), height(height) {}\n\n void draw() override {\n renderer->renderRectangle(width, height);\n }\n};\n```\n\n```go\ntype Rectangle struct {\n\tShape\n\twidth float64\n\theight float64\n}\n\nfunc NewRectangle(renderer Renderer, width, height float64) *Rectangle {\n\treturn &Rectangle{\n\t\tShape: NewShape(renderer),\n\t\twidth: width,\n\t\theight: height,\n\t}\n}\n\nfunc (r *Rectangle) Draw() {\n\tr.renderer.RenderRectangle(r.width, r.height)\n}\n```\n\n```csharp\nclass Rectangle : Shape\n{\n private readonly float width;\n private readonly float height;\n\n public Rectangle(IRenderer renderer, float width, float height) : base(renderer)\n {\n this.width = width;\n this.height = height;\n }\n\n public override void Draw()\n {\n renderer.RenderRectangle(width, height);\n }\n}\n```\n\n```typescript\nclass Rectangle extends Shape {\n private readonly width: number;\n private readonly height: number;\n\n constructor(renderer: Renderer, width: number, height: number) {\n super(renderer);\n this.width = width;\n this.height = height;\n }\n\n draw(): void {\n this.renderer.renderRectangle(this.width, this.height);\n }\n}\n```\n\n\n### Step 5: Client Code\n\nNow we can freely combine shapes and rendering strategies at runtime, without creating a new class for each combination.\n\n\n```java\npublic class BridgeDemo {\n public static void main(String[] args) {\n Renderer vector = new VectorRenderer();\n Renderer raster = new RasterRenderer();\n\n Shape circle1 = new Circle(vector, 5);\n Shape circle2 = new Circle(raster, 5);\n\n Shape rectangle1 = new Rectangle(vector, 10, 4);\n Shape rectangle2 = new Rectangle(raster, 10, 4);\n\n circle1.draw(); // Vector\n circle2.draw(); // Raster\n rectangle1.draw(); // Vector\n rectangle2.draw(); // Raster\n }\n}\n```\n\n```python\ndef bridge_demo():\n vector = VectorRenderer()\n raster = RasterRenderer()\n \n circle1 = Circle(vector, 5)\n circle2 = Circle(raster, 5)\n \n rectangle1 = Rectangle(vector, 10, 4)\n rectangle2 = Rectangle(raster, 10, 4)\n \n circle1.draw() # Vector\n circle2.draw() # Raster\n rectangle1.draw() # Vector\n rectangle2.draw() # Raster\n\n# Example usage\nif __name__ == \"__main__\":\n bridge_demo()\n```\n\n```cpp\nint main() {\n VectorRenderer vector;\n RasterRenderer raster;\n\n Circle circle1(&vector, 5);\n Circle circle2(&raster, 5);\n\n Rectangle rectangle1(&vector, 10, 4);\n Rectangle rectangle2(&raster, 10, 4);\n\n circle1.draw(); // Vector\n circle2.draw(); // Raster\n rectangle1.draw(); // Vector\n rectangle2.draw(); // Raster\n\n return 0;\n}\n```\n\n```go\nfunc bridgeDemo() {\n\tvector := &VectorRenderer{}\n\traster := &RasterRenderer{}\n\n\tcircle1 := NewCircle(vector, 5)\n\tcircle2 := NewCircle(raster, 5)\n\n\trectangle1 := NewRectangle(vector, 10, 4)\n\trectangle2 := NewRectangle(raster, 10, 4)\n\n\tcircle1.Draw() // Vector\n\tcircle2.Draw() // Raster\n\trectangle1.Draw() // Vector\n\trectangle2.Draw() // Raster\n}\n```\n\n```csharp\npublic class BridgeDemo\n{\n public static void Main(string[] args)\n {\n IRenderer vector = new VectorRenderer();\n IRenderer raster = new RasterRenderer();\n\n ShapeBridge circle1 = new Circle(vector, 5);\n ShapeBridge circle2 = new Circle(raster, 5);\n\n ShapeBridge rectangle1 = new Rectangle(vector, 10, 4);\n ShapeBridge rectangle2 = new Rectangle(raster, 10, 4);\n\n circle1.Draw(); // Vector\n circle2.Draw(); // Raster\n rectangle1.Draw(); // Vector\n rectangle2.Draw(); // Raster\n }\n}\n```\n\n```typescript\nclass BridgeDemo {\n static main(): void {\n const vector: Renderer = new VectorRenderer();\n const raster: Renderer = new RasterRenderer();\n\n const circle1: Shape = new Circle(vector, 5);\n const circle2: Shape = new Circle(raster, 5);\n\n const rectangle1: Shape = new Rectangle(vector, 10, 4);\n const rectangle2: Shape = new Rectangle(raster, 10, 4);\n\n circle1.draw(); // Vector\n circle2.draw(); // Raster\n rectangle1.draw(); // Vector\n rectangle2.draw(); // Raster\n }\n}\n```\n\n\n#### **Expected Output:**\n\n\n```plaintext\nDrawing a circle of radius 5.0 using VECTOR rendering.\nDrawing pixels for a circle of radius 5.0 (RASTER).\nDrawing a rectangle 10.0x4.0 using VECTOR rendering.\nDrawing pixels for a rectangle 10.0x4.0 (RASTER).\n```\n\n\n### What We Achieved\n\n- **Decoupled abstractions from implementations: **Shapes and renderers evolve independently\n- **Open/Closed compliance: **You can add new renderers or shapes without modifying existing ones\n- **No class explosion: **Avoided the need for every shape-renderer subclass\n- **Runtime flexibility: **Dynamically switch renderers based on user/device context\n- **Clean, extensible design: **Each class has a single responsibility and can be composed as needed\n\n---\n\n# 5. Practical Example: Remote Control and Devices\n\nTo make sure Bridge clicks beyond the shapes example, let us build a completely different system: remote controls and electronic devices. The abstraction is the remote (basic remote, advanced remote), and the implementation is the device (TV, radio).\n\nA basic remote can toggle power and adjust volume. An advanced remote adds a mute button. Both remotes work with any device.\n\n\n```mermaid\nclassDiagram\n class Device {\n <>\n +isEnabled() bool\n +enable()\n +disable()\n +getVolume() int\n +setVolume(volume)\n }\n\n class TV {\n -enabled: bool\n -volume: int\n +isEnabled() bool\n +enable()\n +disable()\n +getVolume() int\n +setVolume(volume)\n }\n\n class Radio {\n -enabled: bool\n -volume: int\n +isEnabled() bool\n +enable()\n +disable()\n +getVolume() int\n +setVolume(volume)\n }\n\n class Remote {\n <>\n #device: Device\n +togglePower()\n +volumeUp()\n +volumeDown()\n }\n\n class BasicRemote {\n +togglePower()\n +volumeUp()\n +volumeDown()\n }\n\n class AdvancedRemote {\n +togglePower()\n +volumeUp()\n +volumeDown()\n +mute()\n }\n\n Device <|.. TV\n Device <|.. Radio\n Remote <|-- BasicRemote\n Remote <|-- AdvancedRemote\n Remote --> Device : delegates to\n\n style Device fill:#69db7c,stroke:#000,color:#000\n style TV fill:#ffa94d,stroke:#000,color:#000\n style Radio fill:#ffa94d,stroke:#000,color:#000\n style Remote fill:#38d9a9,stroke:#000,color:#000\n style BasicRemote fill:#00ceff,stroke:#000,color:#000\n style AdvancedRemote fill:#00ceff,stroke:#000,color:#000\n```\n\n\nThe Device interface is the Implementor. TV and Radio are ConcreteImplementors. Remote is the Abstraction. BasicRemote and AdvancedRemote are RefinedAbstractions. The bridge is the reference from Remote to Device.\n\n### Implementation\n\n\n```java\n// Implementor\ninterface Device {\n boolean isEnabled();\n void enable();\n void disable();\n int getVolume();\n void setVolume(int volume);\n}\n\n// ConcreteImplementor: TV\nclass TV implements Device {\n private boolean enabled = false;\n private int volume = 30;\n\n @Override\n public boolean isEnabled() { return enabled; }\n\n @Override\n public void enable() {\n enabled = true;\n System.out.println(\"TV: Turned ON\");\n }\n\n @Override\n public void disable() {\n enabled = false;\n System.out.println(\"TV: Turned OFF\");\n }\n\n @Override\n public int getVolume() { return volume; }\n\n @Override\n public void setVolume(int volume) {\n this.volume = Math.max(0, Math.min(100, volume));\n System.out.println(\"TV: Volume set to \" + this.volume);\n }\n}\n\n// ConcreteImplementor: Radio\nclass Radio implements Device {\n private boolean enabled = false;\n private int volume = 20;\n\n @Override\n public boolean isEnabled() { return enabled; }\n\n @Override\n public void enable() {\n enabled = true;\n System.out.println(\"Radio: Turned ON\");\n }\n\n @Override\n public void disable() {\n enabled = false;\n System.out.println(\"Radio: Turned OFF\");\n }\n\n @Override\n public int getVolume() { return volume; }\n\n @Override\n public void setVolume(int volume) {\n this.volume = Math.max(0, Math.min(100, volume));\n System.out.println(\"Radio: Volume set to \" + this.volume);\n }\n}\n\n// Abstraction\nabstract class Remote {\n protected Device device;\n\n public Remote(Device device) {\n this.device = device;\n }\n\n public void togglePower() {\n if (device.isEnabled()) {\n device.disable();\n } else {\n device.enable();\n }\n }\n\n public void volumeUp() {\n device.setVolume(device.getVolume() + 10);\n }\n\n public void volumeDown() {\n device.setVolume(device.getVolume() - 10);\n }\n}\n\n// RefinedAbstraction: BasicRemote\nclass BasicRemote extends Remote {\n public BasicRemote(Device device) {\n super(device);\n }\n}\n\n// RefinedAbstraction: AdvancedRemote\nclass AdvancedRemote extends Remote {\n public AdvancedRemote(Device device) {\n super(device);\n }\n\n public void mute() {\n device.setVolume(0);\n System.out.println(\"AdvancedRemote: Muted\");\n }\n}\n\npublic class RemoteDemo {\n public static void main(String[] args) {\n System.out.println(\"--- Basic Remote with TV ---\");\n Device tv = new TV();\n Remote basicRemote = new BasicRemote(tv);\n basicRemote.togglePower();\n basicRemote.volumeUp();\n basicRemote.volumeUp();\n basicRemote.volumeDown();\n\n System.out.println(\"\\n--- Advanced Remote with Radio ---\");\n Device radio = new Radio();\n AdvancedRemote advancedRemote = new AdvancedRemote(radio);\n advancedRemote.togglePower();\n advancedRemote.volumeUp();\n advancedRemote.mute();\n\n System.out.println(\"\\n--- Advanced Remote with TV ---\");\n AdvancedRemote tvAdvanced = new AdvancedRemote(tv);\n tvAdvanced.volumeUp();\n tvAdvanced.mute();\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\n# Implementor\nclass Device(ABC):\n @abstractmethod\n def is_enabled(self) -> bool:\n pass\n\n @abstractmethod\n def enable(self):\n pass\n\n @abstractmethod\n def disable(self):\n pass\n\n @abstractmethod\n def get_volume(self) -> int:\n pass\n\n @abstractmethod\n def set_volume(self, volume: int):\n pass\n\n# ConcreteImplementor: TV\nclass TV(Device):\n def __init__(self):\n self._enabled = False\n self._volume = 30\n\n def is_enabled(self) -> bool:\n return self._enabled\n\n def enable(self):\n self._enabled = True\n print(\"TV: Turned ON\")\n\n def disable(self):\n self._enabled = False\n print(\"TV: Turned OFF\")\n\n def get_volume(self) -> int:\n return self._volume\n\n def set_volume(self, volume: int):\n self._volume = max(0, min(100, volume))\n print(f\"TV: Volume set to {self._volume}\")\n\n# ConcreteImplementor: Radio\nclass Radio(Device):\n def __init__(self):\n self._enabled = False\n self._volume = 20\n\n def is_enabled(self) -> bool:\n return self._enabled\n\n def enable(self):\n self._enabled = True\n print(\"Radio: Turned ON\")\n\n def disable(self):\n self._enabled = False\n print(\"Radio: Turned OFF\")\n\n def get_volume(self) -> int:\n return self._volume\n\n def set_volume(self, volume: int):\n self._volume = max(0, min(100, volume))\n print(f\"Radio: Volume set to {self._volume}\")\n\n# Abstraction\nclass Remote:\n def __init__(self, device: Device):\n self.device = device\n\n def toggle_power(self):\n if self.device.is_enabled():\n self.device.disable()\n else:\n self.device.enable()\n\n def volume_up(self):\n self.device.set_volume(self.device.get_volume() + 10)\n\n def volume_down(self):\n self.device.set_volume(self.device.get_volume() - 10)\n\n# RefinedAbstraction: BasicRemote\nclass BasicRemote(Remote):\n def __init__(self, device: Device):\n super().__init__(device)\n\n# RefinedAbstraction: AdvancedRemote\nclass AdvancedRemote(Remote):\n def __init__(self, device: Device):\n super().__init__(device)\n\n def mute(self):\n self.device.set_volume(0)\n print(\"AdvancedRemote: Muted\")\n\t\t\ndef main():\n print(\"--- Basic Remote with TV ---\")\n tv = TV()\n basic_remote = BasicRemote(tv)\n basic_remote.toggle_power()\n basic_remote.volume_up()\n basic_remote.volume_up()\n basic_remote.volume_down()\n\n print(\"\\n--- Advanced Remote with Radio ---\")\n radio = Radio()\n advanced_remote = AdvancedRemote(radio)\n advanced_remote.toggle_power()\n advanced_remote.volume_up()\n advanced_remote.mute()\n\n print(\"\\n--- Advanced Remote with TV ---\")\n tv_advanced = AdvancedRemote(tv)\n tv_advanced.volume_up()\n tv_advanced.mute()\n\nif __name__ == \"__main__\":\n main()\t\t\n```\n\n```cpp\n#include \n#include \nusing namespace std;\n\n// Implementor\nclass Device {\npublic:\n virtual ~Device() {}\n virtual bool isEnabled() = 0;\n virtual void enable() = 0;\n virtual void disable() = 0;\n virtual int getVolume() = 0;\n virtual void setVolume(int volume) = 0;\n};\n\n// ConcreteImplementor: TV\nclass TV : public Device {\nprivate:\n bool enabled = false;\n int volume = 30;\n\npublic:\n bool isEnabled() override { return enabled; }\n\n void enable() override {\n enabled = true;\n cout << \"TV: Turned ON\" << endl;\n }\n\n void disable() override {\n enabled = false;\n cout << \"TV: Turned OFF\" << endl;\n }\n\n int getVolume() override { return volume; }\n\n void setVolume(int vol) override {\n volume = max(0, min(100, vol));\n cout << \"TV: Volume set to \" << volume << endl;\n }\n};\n\n// ConcreteImplementor: Radio\nclass Radio : public Device {\nprivate:\n bool enabled = false;\n int volume = 20;\n\npublic:\n bool isEnabled() override { return enabled; }\n\n void enable() override {\n enabled = true;\n cout << \"Radio: Turned ON\" << endl;\n }\n\n void disable() override {\n enabled = false;\n cout << \"Radio: Turned OFF\" << endl;\n }\n\n int getVolume() override { return volume; }\n\n void setVolume(int vol) override {\n volume = max(0, min(100, vol));\n cout << \"Radio: Volume set to \" << volume << endl;\n }\n};\n\n// Abstraction\nclass Remote {\nprotected:\n Device* device;\n\npublic:\n Remote(Device* device) : device(device) {}\n virtual ~Remote() {}\n\n void togglePower() {\n if (device->isEnabled()) {\n device->disable();\n } else {\n device->enable();\n }\n }\n\n void volumeUp() {\n device->setVolume(device->getVolume() + 10);\n }\n\n void volumeDown() {\n device->setVolume(device->getVolume() - 10);\n }\n};\n\n// RefinedAbstraction: BasicRemote\nclass BasicRemote : public Remote {\npublic:\n BasicRemote(Device* device) : Remote(device) {}\n};\n\n// RefinedAbstraction: AdvancedRemote\nclass AdvancedRemote : public Remote {\npublic:\n AdvancedRemote(Device* device) : Remote(device) {}\n\n void mute() {\n device->setVolume(0);\n cout << \"AdvancedRemote: Muted\" << endl;\n }\n};\n\nint main() {\n cout << \"--- Basic Remote with TV ---\" << endl;\n TV tv;\n BasicRemote basicRemote(&tv);\n basicRemote.togglePower();\n basicRemote.volumeUp();\n basicRemote.volumeUp();\n basicRemote.volumeDown();\n\n cout << \"\\n--- Advanced Remote with Radio ---\" << endl;\n Radio radio;\n AdvancedRemote advancedRemote(&radio);\n advancedRemote.togglePower();\n advancedRemote.volumeUp();\n advancedRemote.mute();\n\n cout << \"\\n--- Advanced Remote with TV ---\" << endl;\n AdvancedRemote tvAdvanced(&tv);\n tvAdvanced.volumeUp();\n tvAdvanced.mute();\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\n// Implementor\ntype Device interface {\n\tIsEnabled() bool\n\tEnable()\n\tDisable()\n\tGetVolume() int\n\tSetVolume(volume int)\n}\n\n// ConcreteImplementor: TV\ntype TV struct {\n\tenabled bool\n\tvolume int\n}\n\nfunc NewTV() *TV {\n\treturn &TV{enabled: false, volume: 30}\n}\n\nfunc (t *TV) IsEnabled() bool { return t.enabled }\n\nfunc (t *TV) Enable() {\n\tt.enabled = true\n\tfmt.Println(\"TV: Turned ON\")\n}\n\nfunc (t *TV) Disable() {\n\tt.enabled = false\n\tfmt.Println(\"TV: Turned OFF\")\n}\n\nfunc (t *TV) GetVolume() int { return t.volume }\n\nfunc (t *TV) SetVolume(volume int) {\n\tif volume < 0 {\n\t\tvolume = 0\n\t}\n\tif volume > 100 {\n\t\tvolume = 100\n\t}\n\tt.volume = volume\n\tfmt.Println(\"TV: Volume set to\", t.volume)\n}\n\n// ConcreteImplementor: Radio\ntype Radio struct {\n\tenabled bool\n\tvolume int\n}\n\nfunc NewRadio() *Radio {\n\treturn &Radio{enabled: false, volume: 20}\n}\n\nfunc (r *Radio) IsEnabled() bool { return r.enabled }\n\nfunc (r *Radio) Enable() {\n\tr.enabled = true\n\tfmt.Println(\"Radio: Turned ON\")\n}\n\nfunc (r *Radio) Disable() {\n\tr.enabled = false\n\tfmt.Println(\"Radio: Turned OFF\")\n}\n\nfunc (r *Radio) GetVolume() int { return r.volume }\n\nfunc (r *Radio) SetVolume(volume int) {\n\tif volume < 0 {\n\t\tvolume = 0\n\t}\n\tif volume > 100 {\n\t\tvolume = 100\n\t}\n\tr.volume = volume\n\tfmt.Println(\"Radio: Volume set to\", r.volume)\n}\n\n// Abstraction\ntype Remote struct {\n\tdevice Device\n}\n\nfunc NewRemote(device Device) *Remote {\n\treturn &Remote{device: device}\n}\n\nfunc (r *Remote) TogglePower() {\n\tif r.device.IsEnabled() {\n\t\tr.device.Disable()\n\t} else {\n\t\tr.device.Enable()\n\t}\n}\n\nfunc (r *Remote) VolumeUp() {\n\tr.device.SetVolume(r.device.GetVolume() + 10)\n}\n\nfunc (r *Remote) VolumeDown() {\n\tr.device.SetVolume(r.device.GetVolume() - 10)\n}\n\n// RefinedAbstraction: BasicRemote\ntype BasicRemote struct {\n\t*Remote\n}\n\nfunc NewBasicRemote(device Device) *BasicRemote {\n\treturn &BasicRemote{Remote: NewRemote(device)}\n}\n\n// RefinedAbstraction: AdvancedRemote\ntype AdvancedRemote struct {\n\t*Remote\n}\n\nfunc NewAdvancedRemote(device Device) *AdvancedRemote {\n\treturn &AdvancedRemote{Remote: NewRemote(device)}\n}\n\nfunc (a *AdvancedRemote) Mute() {\n\ta.device.SetVolume(0)\n\tfmt.Println(\"AdvancedRemote: Muted\")\n}\n\nfunc main() {\n\tfmt.Println(\"--- Basic Remote with TV ---\")\n\ttv := NewTV()\n\tbasicRemote := NewBasicRemote(tv)\n\tbasicRemote.TogglePower()\n\tbasicRemote.VolumeUp()\n\tbasicRemote.VolumeUp()\n\tbasicRemote.VolumeDown()\n\n\tfmt.Println(\"\\n--- Advanced Remote with Radio ---\")\n\tradio := NewRadio()\n\tadvancedRemote := NewAdvancedRemote(radio)\n\tadvancedRemote.TogglePower()\n\tadvancedRemote.VolumeUp()\n\tadvancedRemote.Mute()\n\n\tfmt.Println(\"\\n--- Advanced Remote with TV ---\")\n\ttvAdvanced := NewAdvancedRemote(tv)\n\ttvAdvanced.VolumeUp()\n\ttvAdvanced.Mute()\n}\n```\n\n```csharp\nusing System;\n\n// Implementor\ninterface IDevice\n{\n bool IsEnabled();\n void Enable();\n void Disable();\n int GetVolume();\n void SetVolume(int volume);\n}\n\n// ConcreteImplementor: TV\nclass TV : IDevice\n{\n private bool enabled = false;\n private int volume = 30;\n\n public bool IsEnabled() => enabled;\n\n public void Enable()\n {\n enabled = true;\n Console.WriteLine(\"TV: Turned ON\");\n }\n\n public void Disable()\n {\n enabled = false;\n Console.WriteLine(\"TV: Turned OFF\");\n }\n\n public int GetVolume() => volume;\n\n public void SetVolume(int vol)\n {\n volume = Math.Max(0, Math.Min(100, vol));\n Console.WriteLine($\"TV: Volume set to {volume}\");\n }\n}\n\n// ConcreteImplementor: Radio\nclass Radio : IDevice\n{\n private bool enabled = false;\n private int volume = 20;\n\n public bool IsEnabled() => enabled;\n\n public void Enable()\n {\n enabled = true;\n Console.WriteLine(\"Radio: Turned ON\");\n }\n\n public void Disable()\n {\n enabled = false;\n Console.WriteLine(\"Radio: Turned OFF\");\n }\n\n public int GetVolume() => volume;\n\n public void SetVolume(int vol)\n {\n volume = Math.Max(0, Math.Min(100, vol));\n Console.WriteLine($\"Radio: Volume set to {volume}\");\n }\n}\n\n// Abstraction\nabstract class Remote\n{\n protected IDevice device;\n\n public Remote(IDevice device)\n {\n this.device = device;\n }\n\n public void TogglePower()\n {\n if (device.IsEnabled())\n device.Disable();\n else\n device.Enable();\n }\n\n public void VolumeUp()\n {\n device.SetVolume(device.GetVolume() + 10);\n }\n\n public void VolumeDown()\n {\n device.SetVolume(device.GetVolume() - 10);\n }\n}\n\n// RefinedAbstraction: BasicRemote\nclass BasicRemote : Remote\n{\n public BasicRemote(IDevice device) : base(device) {}\n}\n\n// RefinedAbstraction: AdvancedRemote\nclass AdvancedRemote : Remote\n{\n public AdvancedRemote(IDevice device) : base(device) {}\n\n public void Mute()\n {\n device.SetVolume(0);\n Console.WriteLine(\"AdvancedRemote: Muted\");\n }\n}\n\npublic class RemoteDemo\n{\n public static void Main(string[] args)\n {\n Console.WriteLine(\"--- Basic Remote with TV ---\");\n IDevice tv = new TV();\n Remote basicRemote = new BasicRemote(tv);\n basicRemote.TogglePower();\n basicRemote.VolumeUp();\n basicRemote.VolumeUp();\n basicRemote.VolumeDown();\n\n Console.WriteLine(\"\\n--- Advanced Remote with Radio ---\");\n IDevice radio = new Radio();\n var advancedRemote = new AdvancedRemote(radio);\n advancedRemote.TogglePower();\n advancedRemote.VolumeUp();\n advancedRemote.Mute();\n\n Console.WriteLine(\"\\n--- Advanced Remote with TV ---\");\n var tvAdvanced = new AdvancedRemote(tv);\n tvAdvanced.VolumeUp();\n tvAdvanced.Mute();\n }\n}\n```\n\n```typescript\n// Implementor\ninterface Device {\n isEnabled(): boolean;\n enable(): void;\n disable(): void;\n getVolume(): number;\n setVolume(volume: number): void;\n}\n\n// ConcreteImplementor: TV\nclass TV implements Device {\n private enabled = false;\n private volume = 30;\n\n isEnabled(): boolean {\n return this.enabled;\n }\n\n enable(): void {\n this.enabled = true;\n console.log(\"TV: Turned ON\");\n }\n\n disable(): void {\n this.enabled = false;\n console.log(\"TV: Turned OFF\");\n }\n\n getVolume(): number {\n return this.volume;\n }\n\n setVolume(volume: number): void {\n this.volume = Math.max(0, Math.min(100, volume));\n console.log(`TV: Volume set to ${this.volume}`);\n }\n}\n\n// ConcreteImplementor: Radio\nclass Radio implements Device {\n private enabled = false;\n private volume = 20;\n\n isEnabled(): boolean {\n return this.enabled;\n }\n\n enable(): void {\n this.enabled = true;\n console.log(\"Radio: Turned ON\");\n }\n\n disable(): void {\n this.enabled = false;\n console.log(\"Radio: Turned OFF\");\n }\n\n getVolume(): number {\n return this.volume;\n }\n\n setVolume(volume: number): void {\n this.volume = Math.max(0, Math.min(100, volume));\n console.log(`Radio: Volume set to ${this.volume}`);\n }\n}\n\n// Abstraction\nabstract class Remote {\n protected device: Device;\n\n constructor(device: Device) {\n this.device = device;\n }\n\n togglePower(): void {\n if (this.device.isEnabled()) {\n this.device.disable();\n } else {\n this.device.enable();\n }\n }\n\n volumeUp(): void {\n this.device.setVolume(this.device.getVolume() + 10);\n }\n\n volumeDown(): void {\n this.device.setVolume(this.device.getVolume() - 10);\n }\n}\n\n// RefinedAbstraction: BasicRemote\nclass BasicRemote extends Remote {\n constructor(device: Device) {\n super(device);\n }\n}\n\n// RefinedAbstraction: AdvancedRemote\nclass AdvancedRemote extends Remote {\n constructor(device: Device) {\n super(device);\n }\n\n mute(): void {\n this.device.setVolume(0);\n console.log(\"AdvancedRemote: Muted\");\n }\n}\n\nconsole.log(\"--- Basic Remote with TV ---\");\nconst tv: Device = new TV();\nconst basicRemote: Remote = new BasicRemote(tv);\nbasicRemote.togglePower();\nbasicRemote.volumeUp();\nbasicRemote.volumeUp();\nbasicRemote.volumeDown();\n\nconsole.log(\"\\n--- Advanced Remote with Radio ---\");\nconst radio: Device = new Radio();\nconst advancedRemote = new AdvancedRemote(radio);\nadvancedRemote.togglePower();\nadvancedRemote.volumeUp();\nadvancedRemote.mute();\n\nconsole.log(\"\\n--- Advanced Remote with TV ---\");\nconst tvAdvanced = new AdvancedRemote(tv);\ntvAdvanced.volumeUp();\ntvAdvanced.mute();\n```\n\n\nNotice how the same TV object is used with both the basic remote and the advanced remote. The remote hierarchy and the device hierarchy vary independently. Adding a Speaker device means writing one new class. Adding a VoiceRemote means writing one new class. Neither side knows about the other.","pageType":"lld-interviews"}

Get Premium