设计模式（九）Bridge模式

　　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类不需要做任何改变，也就是上面强调的，如果想要增加功能，只需要在“类的功能层次结构”一侧增加类即可，而“类的实现层次结构”不需要做任何改变，最关键的是，增加后的功能可以被“所有的实现”使用。总结来说，这种模式的优点就是，有利于独立地对它们进行扩展。