十. 桥接模式 - Bridge

Bridge模式也叫桥接模式，是由GoF提出的23种软件设计模式的一种。Bridge模式在调用方与被调用方之间使用一个起着“桥”作用的类，用来支持类的多方向扩展。

本文介绍设计模式中的桥接（Bridge）模式的概念，用法，以及实际应用中怎么样使用桥接模式进行开发。

Bridge 模式的概念

Bridge模式是构造型的设计模式之一。Bridge模式基于类的最小设计原则，通过使用封装，聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽象（abstraction）与行为实现（implementation）分离开来，从而可以保持各部分的独立性以及应对它们的功能扩展。

Bridge 模式的应用场景

面向对象的程序设计（OOP）里有类继承（子类继承父类）的概念，如果一个类或接口有多个具体实现子类，如果这些子类具有以下特性：
- 存在相对并列的子类属性。
- 存在概念上的交叉。
- 可变性。
我们就可以用Bridge模式来对其进行抽象与具体，对相关类进行重构。

为了容易理解，我们举例说明一下，比如汽车类（Car），假设有2个子类，卡车类（Truck）与公交车类（Bus），它们有 [设置引擎]这个动作行为，通过不同引擎规格的设置，可以将它们设置为比如为1500cc（Car1500），和2000cc（Car2000）的车。
这样，不管是1500cc的卡车还是2000cc的卡车，抑或是1500cc的公交车还是2000cc的公交车，它们都可以是汽车类的子类，而且：
- 存在相对并列的子类属性。汽车的种类，与汽车引擎规格是汽车的2个并列的属性，没有概念上的重复。
- 存在概念上的交叉。不管是卡车还是公交车，都有1500cc与2000cc引擎规格的车。
- 可变性。除了卡车，公交车之外，可能还有救火车；除了有1500cc与2000cc引擎规格的车之外，还可能有2500cc的车等等。

这样一来，我们怎么来设计汽车类呢？
1，方法一：通过继承设计所有可能存在的子类。可能我们会想到下面的这种继承关系：
汽车总类：Car
汽车子类 - 按种类分类：Bus，Truck
汽车子类 - 按引擎分类：Bus1500，Bus2000，Truck1500，Truck2000
这样设置引擎这个动作就由各个子类加以实现。

但如果以后需要增加一种救火车（FireCar），以及增加一个引擎规格2500cc，需要实现的子类将会有：
Bus1500，Bus2000，Bus2500，Truck1500，Truck2000，Truck2500，FireCar1500，FireCar2000，FireCar2500
多达9个。
也就是说，这种设计方法，子类数目将随几何级数增长。
而且，Bus1500，Truck1500的引擎规格相同，它们的引擎设置动作应该是一样的，但现在把它们分成不同的子类，难以避免执行重复的动作行为。


2，方法二：分别为Bus以及Truck实现设置不同引擎的方法
汽车总类：Car
汽车子类：Bus，Truck

然后在Bus类里分别提供1500cc以及2000cc引擎的设置方法：
Bus extends Car {
    public setEngine1500cc();
    public setEngine2000cc();
}

在Truck类里也分别提供1500cc以及2000cc引擎的设置方法：
Truck extends Car {
    public setEngine1500cc();
    public setEngine2000cc();
}

这种情况，子类的数量是被控制了。但一方面，如果每增加一种引擎规格，需要修改所有的汽车子类；另一方面，即使引擎的设置行为一样，但是不同的汽车子类却需要提供完全一样的方法。

在实际的应用开发中，以上2种方法都会造成迁一发而动全身，而且会存在大量的重复代码。

Bridge模式可以很好的解决这类问题。
我们先看看Bridge模式的类图描述：

[图：出自wikipedia.org]

Client
    Bridge模式的使用者
Abstraction
    抽象类接口（接口或抽象类）
    维护对行为实现（Implementor）的引用
Refined Abstraction
    Abstraction子类
Implementor
    行为实现类接口 (Abstraction接口定义了基于Implementor接口的更高层次的操作)
ConcreteImplementor
    Implementor 子类

Bridge 模式的应用范例

我们来看看怎么应用Bridge模式来设计汽车类。

抽象 - Abstraction类：汽车类及其子类：
Car：汽车总类
Truck：汽车子类 - 卡车类。
Bus：汽车子类 - 公交车类。

行为实现 - Implementor：汽车引擎设置的行为类及子类
SetCarEngine：汽车引擎的设置接口
SetCarEngine1500cc：设置1500cc引擎
SetCarEngine2000cc：设置2000cc引擎

Client类：使用Bridge模式
Client：测试

代码：

view plainprint?

1. //测试  
2. public class Client {  
3.   
4.     public static void main(String[] args) {  
5.         SetCarEngine carEngine1500cc = new SetCarEngine1500cc();  
6.         SetCarEngine carEngine2000cc = new SetCarEngine2000cc();  
7.           
8.         Car truck1500cc = new Truck(carEngine1500cc);  
9.         Car truck2000cc = new Truck(carEngine2000cc);  
10.           
11.         truck1500cc.setEngine();  
12.         truck2000cc.setEngine();  
13.           
14.         Car bus1500cc = new Bus(carEngine1500cc);  
15.         Car bus2000cc = new Bus(carEngine2000cc);  
16.           
17.         bus1500cc.setEngine();  
18.         bus2000cc.setEngine();  
19.     }  
20.   
21. }  
22.   
23.   
24. /** "Abstraction" */  
25. //汽车类的抽象  
26. abstract class Car {  
27.     SetCarEngine setCarEngine;  
28.       
29.     public abstract void setEngine();  
30. }  
31.   
32. /** Refined Abstraction */  
33. //Abstraction子类：这里为汽车抽象类的子类  
34. class Truck extends Car {  
35.     public Truck(SetCarEngine setCarEngine) {  
36.         this.setCarEngine = setCarEngine;  
37.     }  
38.       
39.     public void setEngine() {  
40.         System.out.print("Set Truck Engine: ");  
41.           
42.         setCarEngine.setEngine();  
43.     }  
44. }  
45.   
46. class Bus extends Car {  
47.     public Bus(SetCarEngine setCarEngine) {  
48.         this.setCarEngine = setCarEngine;  
49.     }  
50.       
51.     public void setEngine() {  
52.         System.out.print("Set Bus Engine: ");  
53.         setCarEngine.setEngine();  
54.     }  
55. }  
56.   
57.   
58. /** "Implementor" */  
59. //汽车类的行为实现  
60. interface SetCarEngine {  
61.     public void setEngine();  
62. }  
63.   
64. /** ConcreteImplementor */  
65. //行为实现子类  
66. class SetCarEngine1500cc implements SetCarEngine {  
67.     public void setEngine() {  
68.         System.out.println("1500cc");  
69.     }  
70. }  
71.   
72. class SetCarEngine2000cc implements SetCarEngine {  
73.     public void setEngine() {  
74.         System.out.println("2000cc");  
75.     }  
76. }  

//测试public class Client {    public static void main(String[] args) {        SetCarEngine carEngine1500cc = new SetCarEngine1500cc();        SetCarEngine carEngine2000cc = new SetCarEngine2000cc();                Car truck1500cc = new Truck(carEngine1500cc);        Car truck2000cc = new Truck(carEngine2000cc);                truck1500cc.setEngine();        truck2000cc.setEngine();                Car bus1500cc = new Bus(carEngine1500cc);        Car bus2000cc = new Bus(carEngine2000cc);                bus1500cc.setEngine();        bus2000cc.setEngine();    }}/** "Abstraction" *///汽车类的抽象abstract class Car {    SetCarEngine setCarEngine;        public abstract void setEngine();}/** Refined Abstraction *///Abstraction子类：这里为汽车抽象类的子类class Truck extends Car {    public Truck(SetCarEngine setCarEngine) {        this.setCarEngine = setCarEngine;    }        public void setEngine() {        System.out.print("Set Truck Engine: ");                setCarEngine.setEngine();    }}class Bus extends Car {    public Bus(SetCarEngine setCarEngine) {        this.setCarEngine = setCarEngine;    }        public void setEngine() {        System.out.print("Set Bus Engine: ");        setCarEngine.setEngine();    }}/** "Implementor" *///汽车类的行为实现interface SetCarEngine {    public void setEngine();}/** ConcreteImplementor *///行为实现子类class SetCarEngine1500cc implements SetCarEngine {    public void setEngine() {        System.out.println("1500cc");    }}class SetCarEngine2000cc implements SetCarEngine {    public void setEngine() {        System.out.println("2000cc");    }}

执行Client，输出结果：

C:/Bridge>javac *.java
C:/Bridge>java Client
Set Truck Engine: 1500cc
Set Truck Engine: 2000cc
Set Bus Engine: 1500cc
Set Bus Engine: 2000cc
C:/Bridge>