📅 Week-5 (Day-5) - Exploring Real-World Applications and Code Examples of the Bridge Design Pattern

NOTE: - I started my 8-week system design journey with Coder Army. I will be journaling every day, recording what I learn, reflecting on it, and sharing it with my network to help newcomers to system design.

💠 What is the Bridge Design Pattern?

Definition: Bridge Pattern decouples an abstraction from its implementation so that both can vary independently.

(Hindi: Bridge Pattern ek abstraction ko uske implementation se alag karta hai taaki dono apne-apne tareeke se badal sakein, bina ek doosre ko impact kiye.)

💠The Problem It Solves

When you mix different types of features in one place — like Car types (SUV, Sedan) and Engines (Diesel, Petrol, Electric) — you end up with too many subclasses. Every combination leads to a new class:

SUV + Petrol => SUVPetrol SUV + Diesel => SUVDiesel Sedan + Petrol => SedanPetrol ... and so on

This is called Class Explosion

• Difficult to maintain

• Poor code reuse

• Complex relationships

(Hindi: Har naye combination ke liye ek naye class banani padti hai — isse system complex ho jaata hai aur maintain karna mushkil.)

💠Bridge Pattern to the Rescue

With Bridge Pattern:

• Abstractions like Car are separate from implementations like Engine

• You can mix and match them at runtime without creating a new class for each combo

💠Separation Example:

• Abstraction Layer ➡️ Car (Sedan, SUV)

• Implementation Layer ➡️ Engine (Petrol, Diesel, Electric)

(Hindi: Car aur Engine alag layers me honge — Car sirf ek abstraction hogi aur Engine ek implementation.)

💠Real-World Examples

1️⃣ Remote Control

• Abstraction: Remote (BasicRemote, AdvancedRemote)

• Implementation: Devices (TV, Radio, AC)

2️⃣ UI Elements on OS

• Abstraction: UI Components (Dropdown, Button)

• Implementation: OS (Windows, Linux, macOS)

💠 When to Use Bridge Pattern?

✅ When you need independent variations of abstraction and implementation

✅ When there’s risk of class explosion

✅ When you want clean separation of concerns

📚 Benefits

• Promotes code reuse

• Keeps abstractions flexible

• Encourages clean separation

• Supports Open/Closed Principle (OCP)

(Hindi: Bridge pattern code ko reuseable, flexible, aur maintainable banata hai. Dono hierarchy apne hisaab se badal sakti hai.)

The Bridge Pattern helps us build large, scalable systems where combinations can change — without rewriting the entire architecture. Perfect for multi-platform UI, payment gateways, devices, or anything with "mix-and-match" behavior!

// Implementation Hierarchy: Engine interface (LLL)
interface Engine {
    void start();
}

// Concrete Implementors (LLL)
class PetrolEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Petrol engine starting with ignition!");
    }
}

class DieselEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Diesel engine roaring to life!");
    }
}

class ElectricEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Electric engine powering up silently!");
    }
}

// Abstraction Hierarchy: Car (HLL)
abstract class Car {
    protected Engine engine;
    public Car(Engine e) {
        this.engine = e;
    }
    public abstract void drive();
}

// Refined Abstraction: Sedan
class Sedan extends Car {
    public Sedan(Engine e) {
        super(e);
    }

    @Override
    public void drive() {
        engine.start();
        System.out.println("Driving a Sedan on the highway.");
    }
}

// Refined Abstraction: SUV
class SUV extends Car {
    public SUV(Engine e) {
        super(e);
    }

    @Override
    public void drive() {
        engine.start();
        System.out.println("Driving an SUV off-road.");
    }
}

public class BridgePattern {
    public static void main(String[] args) {
        // Create Engine implementations
        Engine petrolEng = new PetrolEngine();
        Engine dieselEng = new DieselEngine();
        Engine electricEng = new ElectricEngine();

        // Create Car abstractions, injecting Engine implementations
        Car mySedan = new Sedan(petrolEng);
        Car mySUV = new SUV(electricEng);
        Car yourSUV = new SUV(dieselEng);

        // Use the cars
        mySedan.drive();   // Petrol engine + Sedan
        mySUV.drive();     // Electric engine + SUV
        yourSUV.drive();   // Diesel engine + SUV

        // No explicit cleanup needed in Java
    }
}

Week - 5 (Day-5) Completed ✅ System Design

NOTE : - A big thanks to my mentors Rohit Negi Sir and Aditya Sir for launching this amazing 8-week course absolutely free on YouTube via CoderArmy9 :- youtube.com/@CoderArmy9 . 🙌

👉 Share this blog with your connections! Let’s keep learning, growing, and supporting one another on this journey. 🚀

✍️ Payal Kumari 👩‍💻

Jai Hind 🇮🇳 | #CoderArmy #LearningInPublic #SystemDesign #TechForAll #MentorshipMatters #8weeksLLdChallenge #LowLevelDesign #LLD 👩‍💻