桥梁模式

1. 意图（Intent）

将抽象与实现分离开来，使它们可以独立变化。

理解桥梁模式，其实就是理解代码抽象和解耦。

2. 类图（Class Diagram）

• Abstraction ：定义抽象类的接口
• Implementor：定义实现类的接口

3. 实现（Implementation）

I 画图案例

我们首先需要一个桥梁，它是一个接口，定义提供的接口方法。 [ Implementor ]

public interface DrawAPI {
   public void draw(int radius, int x, int y);
}

然后是一系列实现类：[ ConcreteImplementor ]

public class RedPen implements DrawAPI {
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }
}

public class GreenPen implements DrawAPI {
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }
}

public class BluePen implements DrawAPI {
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }
}

定义一个抽象类，此类的实现类都需要使用 DrawAPI：[ Abstraction ]

public abstract class Shape {
    protected DrawAPI drawAPI;
    protected Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }
    public abstract void draw();
}

定义抽象类的子类：

圆形类

public class Circle extends Shape {
    private int radius;
    public Circle(int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.radius = radius;
    }
    public void draw() {
        drawAPI.draw(radius, 0, 0);
    }
}

长方形类

public class Rectangle extends Shape {
    private int x;
    private int y;
    public Rectangle(int x, int y, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
    }
    public void draw() {
        drawAPI.draw(0, x, y);
    }
}

最后，我们来看客户端演示：

public class Client {
    public static void main(String[] args) {
        Shape greenCircle = new Circle(10, new GreenPen());
        Shape redRectangle = new Rectangle(4, 8, new RedPen());
        greenCircle.draw();
        redRectangle.draw();
    }
}

可能大家看上面一步步还不是特别清晰，我把所有的东西整合到一张图上：

这回大家应该就知道抽象在哪里，怎么解耦了吧。桥梁模式的优点也是显而易见的，就是非常容易进行扩展。

II 电视遥控

RemoteControl 表示遥控器 [ Abstraction ]、TV 表示电视 [ Implementor ]
桥接模式将遥控器和电视分离开来，从而可以独立改变遥控器或者电视的实现。

我们首先需要一个桥梁，它是一个接口，定义提供的接口方法，本案例中是 TV [ Implementor ]

public abstract class TV {
    public abstract void on();
    public abstract void off();
    public abstract void tuneChannel();
}

然后是一系列实现类：[ ConcreteImplementor ]
索尼电视机类

public class Sony extends TV {
    @Override
    public void on() {
        System.out.println("Sony.on()");
    }
    @Override
    public void off() {
        System.out.println("Sony.off()");
    }
    @Override
    public void tuneChannel() {
        System.out.println("Sony.tuneChannel()");
    }
}

RCA 电视机类

public class RCA extends TV {
    @Override
    public void on() {
        System.out.println("RCA.on()");
    }
    @Override
    public void off() {
        System.out.println("RCA.off()");
    }
    @Override
    public void tuneChannel() {
        System.out.println("RCA.tuneChannel()");
    }
}

定义一个抽象类，此类的实现类都需要使用 TV ，本案例中是遥控器抽象类：[ Abstraction ]

public abstract class RemoteControl {
    protected TV tv;
    public RemoteControl(TV tv) {
        this.tv = tv;
    }
    public abstract void on();
    public abstract void off();
    public abstract void tuneChannel();
}

定义遥控器抽象类的子类：

A 遥控器

public class ConcreteRemoteControlA extends RemoteControl {
    public ConcreteRemoteControl1(TV tv) {
        super(tv);
    }
    @Override
    public void on() {
        System.out.println("ConcreteRemoteControlA.on()");
        tv.on();
    }
    @Override
    public void off() {
        System.out.println("ConcreteRemoteControlA.off()");
        tv.off();
    }
    @Override
    public void tuneChannel() {
        System.out.println("ConcreteRemoteControlA.tuneChannel()");
        tv.tuneChannel();
    }
}

B 遥控器

public class ConcreteRemoteControlB extends RemoteControl {
    public ConcreteRemoteControl1(TV tv) {
        super(tv);
    }
    @Override
    public void on() {
        System.out.println("ConcreteRemoteControlB.on()");
        tv.on();
    }
    @Override
    public void off() {
        System.out.println("ConcreteRemoteControlB.off()");
        tv.off();
    }
    @Override
    public void tuneChannel() {
        System.out.println("ConcreteRemoteControlB.tuneChannel()");
        tv.tuneChannel();
    }
}

客户端使用代码

public class Client {
    public static void main(String[] args) {
        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
        remoteControl1.on();
        remoteControl1.off();
        remoteControl1.tuneChannel();
        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
        remoteControl2.on();
        remoteControl2.off();
        remoteControl2.tuneChannel();
    }
}

4. JDK

• AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
• JDBC