Bridge Design Pattern

// Implementation interface (the "bridge" target)
public interface Renderer {
    void renderCircle(double radius);
    void renderSquare(double side);
    void renderTriangle(double base, double height);
}

// Concrete Implementations
public class OpenGLRenderer implements Renderer {
    @Override
    public void renderCircle(double radius) {
        System.out.println("OpenGL: Drawing circle with radius " + radius);
    }

    @Override
    public void renderSquare(double side) {
        System.out.println("OpenGL: Drawing square with side " + side);
    }

    @Override
    public void renderTriangle(double base, double height) {
        System.out.println("OpenGL: Drawing triangle " + base + "x" + height);
    }
}

public class SVGRenderer implements Renderer {
    @Override
    public void renderCircle(double radius) {
        System.out.println("SVG: <circle r=\"" + radius + "\"/>");
    }

    @Override
    public void renderSquare(double side) {
        System.out.println("SVG: <rect width=\"" + side + "\" height=\"" + side + "\"/>");
    }

    @Override
    public void renderTriangle(double base, double height) {
        System.out.println("SVG: <polygon points=\"...\"/> (triangle)");
    }
}

// Abstraction
public abstract class Shape {
    protected final Renderer renderer; // BRIDGE

    protected Shape(Renderer renderer) {
        this.renderer = renderer;
    }

    public abstract void draw();
    public abstract void resize(double factor);
}

// Refined Abstractions
public class Circle extends Shape {
    private double radius;

    public Circle(Renderer renderer, double radius) {
        super(renderer);
        this.radius = radius;
    }

    @Override
    public void draw() {
        renderer.renderCircle(radius);
    }

    @Override
    public void resize(double factor) {
        radius *= factor;
    }
}

public class Square extends Shape {
    private double side;

    public Square(Renderer renderer, double side) {
        super(renderer);
        this.side = side;
    }

    @Override
    public void draw() {
        renderer.renderSquare(side);
    }

    @Override
    public void resize(double factor) {
        side *= factor;
    }
}

// Client — mix any shape with any renderer
public class DrawingApp {
    public static void main(String[] args) {
        Renderer opengl = new OpenGLRenderer();
        Renderer svg = new SVGRenderer();

        Shape circle = new Circle(opengl, 5.0);
        Shape square = new Square(svg, 10.0);

        circle.draw(); // OpenGL: Drawing circle with radius 5.0
        square.draw(); // SVG: <rect width="10.0" height="10.0"/>

        // Easy to switch renderer at runtime!
        Shape svgCircle = new Circle(svg, 3.0);
        svgCircle.draw(); // SVG: <circle r="3.0"/>
    }
}

// Implementation — how to send
public interface MessageSender {
    void send(String recipient, String message);
}

public class EmailSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("Email to " + recipient + ": " + message);
    }
}

public class SmsSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("SMS to " + recipient + ": " + message);
    }
}

public class SlackSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("Slack to #" + recipient + ": " + message);
    }
}

// Abstraction — what to send
public abstract class Notification {
    protected final MessageSender sender; // BRIDGE

    protected Notification(MessageSender sender) {
        this.sender = sender;
    }

    public abstract void notify(String recipient, String event);
}

// Refined Abstractions
public class UrgentNotification extends Notification {
    public UrgentNotification(MessageSender sender) {
        super(sender);
    }

    @Override
    public void notify(String recipient, String event) {
        String message = "🚨 URGENT: " + event + " — Immediate action required!";
        sender.send(recipient, message);
        sender.send(recipient, "REMINDER: " + message); // Send twice for urgency
    }
}

public class RegularNotification extends Notification {
    public RegularNotification(MessageSender sender) {
        super(sender);
    }

    @Override
    public void notify(String recipient, String event) {
        sender.send(recipient, "Info: " + event);
    }
}

// Usage — any notification type x any sender
public class AlertSystem {
    public static void main(String[] args) {
        Notification urgentEmail = new UrgentNotification(new EmailSender());
        Notification regularSlack = new RegularNotification(new SlackSender());
        Notification urgentSms = new UrgentNotification(new SmsSender());

        urgentEmail.notify("admin@company.com", "Server CPU at 95%");
        regularSlack.notify("engineering", "Deploy v2.3 complete");
        urgentSms.notify("+1234567890", "Database connection pool exhausted");
    }
}

// Implementation — database technology
public interface DatabaseEngine {
    void connect(String connectionString);
    void execute(String query);
    List<Map<String, Object>> fetch(String query);
    void disconnect();
}

public class MySqlEngine implements DatabaseEngine {
    @Override
    public void connect(String connectionString) {
        System.out.println("MySQL connected: " + connectionString);
    }

    @Override
    public void execute(String query) {
        System.out.println("MySQL executing: " + query);
    }

    @Override
    public List<Map<String, Object>> fetch(String query) {
        System.out.println("MySQL fetching: " + query);
        return List.of();
    }

    @Override
    public void disconnect() {
        System.out.println("MySQL disconnected");
    }
}

public class PostgresEngine implements DatabaseEngine {
    @Override
    public void connect(String connectionString) {
        System.out.println("Postgres connected: " + connectionString);
    }

    @Override
    public void execute(String query) {
        System.out.println("Postgres executing: " + query);
    }

    @Override
    public List<Map<String, Object>> fetch(String query) {
        System.out.println("Postgres fetching: " + query);
        return List.of();
    }

    @Override
    public void disconnect() {
        System.out.println("Postgres disconnected");
    }
}

// Abstraction — repository operations
public abstract class Repository<T> {
    protected final DatabaseEngine engine;

    protected Repository(DatabaseEngine engine) {
        this.engine = engine;
    }

    public abstract void save(T entity);
    public abstract T findById(Long id);
    public abstract List<T> findAll();
}

// Refined Abstraction
public class UserRepository extends Repository<User> {
    public UserRepository(DatabaseEngine engine) {
        super(engine);
    }

    @Override
    public void save(User user) {
        engine.execute("INSERT INTO users (name, email) VALUES ('" +
                       user.name() + "', '" + user.email() + "')");
    }

    @Override
    public User findById(Long id) {
        List<Map<String, Object>> results = engine.fetch(
            "SELECT * FROM users WHERE id = " + id);
        // Map results to User
        return new User(id, "mapped_name", "mapped_email");
    }

    @Override
    public List<User> findAll() {
        engine.fetch("SELECT * FROM users");
        return List.of();
    }
}

// Swap database without touching repository logic!
UserRepository mysqlRepo = new UserRepository(new MySqlEngine());
UserRepository pgRepo = new UserRepository(new PostgresEngine());