Bridge模式就是将类的功能层次结构和类的实现层次结构连接起来。
类的功能层次结构就是根据实际非抽象类来说的，也就是父类具有基本功能，然后在子类中增加新功能。用于增加新功能。
类的实现层次结构就是根据抽象类来说的，也就是父类通过声明抽象方法来定义接口，子类通过实现具体方法来实现接口。用于增加新实现。
package bigjunoba.bjtu.function;
import bigjunoba.bjtu.implement.DisplatImpl;
public class Display {
private DisplatImpl impl;
public Display(DisplatImpl impl) {
this.impl = impl;
}
public void open() {
impl.rawOpen();
}
public void pring() {
impl.rawPrint();
}
public void close() {
impl.rawClose();
}
public final void display() {
open();
pring();
close();
}
}
Display类位于“类的功能层次结构”的最上层。这里的原理和Builder模式比较一下还是有点相似的。DisplatImpl类是个抽象类，定义了三个抽象方法。同样的Display类通过构造函数将DisplatImpl类传递进来，由于抽象类不能被实例化，因此传递进来的也就是DisplatImpl的子类，并保存在impl字段中。impl字段就是类的两个层次结构的“桥梁”。
package bigjunoba.bjtu.function;
import bigjunoba.bjtu.implement.DisplatImpl;
public class CountDisplay extends Display{
public CountDisplay(DisplatImpl impl) {
super(impl);
}
public void multiDisplay(int times) {
open();
for (int i = 0; i < times; i++) {
pring();
}
close();
}
}
CountDisplay类位于“类的功能层次结构”的最下层。CountDisplay类继承了Display类，用于在Display类的基础上增加一个新功能。首先通过构造器调用父类的构造函数，然后multiDisplay方法用来增加新的功能。
下面来看一下“类的实现层次结构”部分。也就是桥的另外一侧。
package bigjunoba.bjtu.implement;
public abstract class DisplatImpl {
public abstract void rawOpen();
public abstract void rawPrint();
public abstract void rawClose();
}
DisplatImpl位于“类的实现层次结构”的最上层。声明了三个抽象方法。
package bigjunoba.bjtu.implement;
public class StringDisplayImpl extends DisplatImpl{
private String string;
private int width;
public StringDisplayImpl(String string) {
this.string = string;
this.width = string.getBytes().length;
}
@Override
public void rawOpen() {
printLine();
}
@Override
public void rawPrint() {
System.out.println("|" + string + "|");
}
@Override
public void rawClose() {
printLine();
}
private void printLine() {
System.out.print("+");
for (int i = 0; i < width; i++) {
System.out.print("-");
}
System.out.println("+");
}
}
StringDisplayImpl类位于“类的实现层次结构”的最下层。作为DisplatImpl类的子类，用来实现DisplatImpl类的三个抽象方法。
package bigjunoba.bjtu.test; import bigjunoba.bjtu.function.CountDisplay;
import bigjunoba.bjtu.function.Display;
import bigjunoba.bjtu.implement.StringDisplayImpl; public class Main { public static void main(String[] args) {
Display display1 = new Display(new StringDisplayImpl("Lianjiang"));
Display display2 = new CountDisplay(new StringDisplayImpl("Lianjiangjiang"));
CountDisplay countDisplay = new CountDisplay(new StringDisplayImpl("Lianjiangjiangjiang"));
display1.display();
display2.display();
countDisplay.display();
countDisplay.multiDisplay(5);
}
}
Main类作为测试类，这里需要好好理解一下。这三个实例的创建都是先向StringDisplayImpl类传递一个String类型的字符串，然后通过StringDisplayImpl类的构造器生成的对应的三个实例。display1字段保存的是Display类的构造器通过接受DisplayImpl抽象类的子类生成的实例也就是impl，然后生成了Display类的实例。display2字段保存的是具有新功能的Display类的实例。而countDisplay字段保存的也是具有新功能的CountDisplay类的实例，由于CountDisplay类是Display类的子类，本质上来说还是属于Display类的实例，说白了就是既可以调用Display类的基本功能，也可以调用CountDisplay类的新功能。
+---------+
|Lianjiang|
+---------+
+--------------+
|Lianjiangjiang|
+--------------+
+-------------------+
|Lianjiangjiangjiang|
+-------------------+
+-------------------+
|Lianjiangjiangjiang|
|Lianjiangjiangjiang|
|Lianjiangjiangjiang|
|Lianjiangjiangjiang|
|Lianjiangjiangjiang|
+-------------------+
输出结果是这样的。结合上述分析来看就很明显了。
下面是Bridge模式的类图。
这里就不解释了。结合示例程序看就很容易理解。要强调的一点是，如果想要增加功能，只需要在“类的功能层次结构”一侧增加类即可，而“类的实现层次结构”不需要做任何改变，最关键的是，增加后的功能可以被“所有的实现”使用。
扩展部分：继承和委托。
继承是一种强关联关系。通俗来说，就是如果不修改代码，那么就很难改变子类和父类之间的关系。
委托是一种弱关联关系。例如，示例中，Display类的impl字段保存了实现的实例，这样类的任务就发生了转移，比如调用open方法就会调用impl.rawOpen方法，也就是如果想让Display类工作，这个时候Display类就不自己工作，而是交给impl，让impl去工作。这就是“委托”。更加深入地理解，弱关联是因为，只有Display类的实例生成时，才与作为参数被传入的类构成关联。示例中的Main类，只有生成DIsplay类和CountDisplay类的实例时，才将StringDisplayImpl的实例作为参数传递给Display类和CountDisplay类。还有一个优点就是，如果新加了一个实现，就是讲其他ConcreteImplementor类的实例传递给Display类和CountDisplay类时也可以轻松实现，而其他Display类和DisplayImpl类不需要做任何改变，也就是上面强调的，如果想要增加功能，只需要在“类的功能层次结构”一侧增加类即可，而“类的实现层次结构”不需要做任何改变，最关键的是，增加后的功能可以被“所有的实现”使用。总结来说，这种模式的优点就是，有利于独立地对它们进行扩展。