Bridge Design Pattern

The Bridge Design Pattern is a structural design pattern that separates abstraction from implementation, allowing them to vary independently. It involves creating a bridge interface that acts as a bridge between the abstraction (client code) and the implementation (implementation-specific classes). This pattern is particularly useful when you want to avoid a permanent binding between an abstraction and its implementation.

Here's a simple example in Java to illustrate the Bridge Pattern:

java
Copy code
// Abstraction
interface Shape {
    void draw();
}

// Implementor
interface DrawingAPI {
    void drawCircle(int x, int y, int radius);
}

// Concrete Implementor 1
class DrawingAPI1 implements DrawingAPI {
    @Override
    public void drawCircle(int x, int y, int radius) {
        System.out.printf("API1 - Drawing circle at (%d, %d) with radius %d%n", x, y, radius);
    }
}

// Concrete Implementor 2
class DrawingAPI2 implements DrawingAPI {
    @Override
    public void drawCircle(int x, int y, int radius) {
        System.out.printf("API2 - Drawing circle at (%d, %d) with radius %d%n", x, y, radius);
    }
}

// Refined Abstraction
class Circle implements Shape {
    private int x, y, radius;
    private DrawingAPI drawingAPI;

    public Circle(int x, int y, int radius, DrawingAPI drawingAPI) {
        this.x = x;
        this.y = y;
        this.radius = radius;
        this.drawingAPI = drawingAPI;
    }

    @Override
    public void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
}

// Client code
public class Client {
    public static void main(String[] args) {
        DrawingAPI api1 = new DrawingAPI1();
        DrawingAPI api2 = new DrawingAPI2();

        Shape circle1 = new Circle(1, 2, 3, api1);
        Shape circle2 = new Circle(5, 7, 11, api2);

        circle1.draw(); // Output: API1 - Drawing circle at (1, 2) with radius 3
        circle2.draw(); // Output: API2 - Drawing circle at (5, 7) with radius 11
    }
}
In this example:

Shape is the abstraction interface.
DrawingAPI is the implementor interface.
DrawingAPI1 and DrawingAPI2 are concrete implementors.
Circle is the refined abstraction that uses the implementor interface.
The client code (Client) creates circles with different drawing APIs, and the circles delegate the drawing operation to their respective drawing APIs.
The Bridge Pattern allows the abstraction (Circle) and the implementation (DrawingAPI) to evolve independently. If you want to add more shapes or more drawing APIs, you can do so without modifying existing classes.