Bridge

// Implementor interface — lower-level rendering operations
public interface Color {
    void applyColor();
}

// Concrete Implementors
public class RedColor implements Color {
    public void applyColor() { System.out.println("Applying RED color"); }
}
public class BlueColor implements Color {
    public void applyColor() { System.out.println("Applying BLUE color"); }
}
public class GreenColor implements Color {
    public void applyColor() { System.out.println("Applying GREEN color"); }
}

// Abstraction — holds reference to Implementor (the bridge)
public abstract class Shape {
    protected Color color; // THE BRIDGE — composition over inheritance

    public Shape(Color color) { this.color = color; }

    public abstract void draw();
}

// Refined Abstractions — vary independently of Color
public class Circle extends Shape {
    private int radius;

    public Circle(int radius, Color color) {
        super(color);
        this.radius = radius;
    }

    public void draw() {
        System.out.print("Circle radius=" + radius + " — ");
        color.applyColor(); // delegates to implementor
    }
}

public class Square extends Shape {
    private int side;

    public Square(int side, Color color) {
        super(color);
        this.side = side;
    }

    public void draw() {
        System.out.print("Square side=" + side + " — ");
        color.applyColor();
    }
}

// Client — combines any shape with any color freely
public class Main {
    public static void main(String[] args) {
        Shape redCircle  = new Circle(10, new RedColor());
        Shape blueSquare = new Square(5,  new BlueColor());
        Shape greenCircle = new Circle(7, new GreenColor());

        redCircle.draw();   // Circle radius=10 — Applying RED color
        blueSquare.draw();  // Square side=5 — Applying BLUE color
        greenCircle.draw(); // Circle radius=7 — Applying GREEN color

        // Switch implementor at runtime — the bridge flexes!
        redCircle.color = new BlueColor();
        redCircle.draw(); // same circle, now blue
    }
}

// ❌ BREAKING — downcasting implementor
public void draw() {
    ((RedColor) color).applySpecialEffect(); // ❌ tied to concrete impl
}

// ✅ FIX — only call interface methods
public void draw() {
    color.applyColor(); // ✅ only Implementor interface methods
}

// ❌ BREAKING — null implementor
Shape broken = new Circle(5, null); // NPE on draw()

// ✅ FIX — validate in constructor
public Shape(Color color) {
    if (color == null)
        throw new IllegalArgumentException("Color implementor required");
    this.color = color;
}

// ✅ OR — use NullObject pattern as safe default
public class NoColor implements Color {
    public void applyColor() { /* intentional no-op safe default */ }
}

// ❌ BREAKING — public bridge field, client corrupts it
public Color color; // client sets incompatible object

// ✅ FIX — protected with validated setter
protected Color color;
public void setColor(Color c) {
    if (c == null) throw new IllegalArgumentException("null not allowed");
    this.color = c;
}