桥接(Bridge)模式

　　桥接模式又称为柄体模式或接口模式。桥接模式的用意就是"将抽象化与实现化解耦，使得二者可以独立变化"。

抽象化：

　　存在于多个实体中的共同的概念性联系，就是抽象化。作为一个过程，抽象化就是忽略一些信息，从而把不同实体当做同样的实体对待。

实现化：

　　抽象化给出的具体实现，就是实现化。

脱耦：

　　耦合是指两个实体的行为的某种强关联。将它们的强关联去掉，就是耦合的解脱或称脱耦。在这里脱耦是将抽象化和实现化的耦合解脱开，或者说是将它们的强关联变为弱关联。继承是强关联。

　　强关联是指编译时期已经确定的，无法在运行时期动态改变的关联；所谓弱关联就是可以动态地确定并在运行时动态地改变的关联。聚合是弱关联。

　　将两个角色的继承关系改为聚合关系，就是将它们之间强关联变为弱关联。因此，桥梁模式的脱耦，就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立地变化。

1.  类图与角色

　　

这个系统有两个等级结构：

由抽象化角色和修正抽象化角色组成的抽象化等级结构；

由实现化角色和两个具体实现化角色所组成的实现化等级结构。

涉及的角色有：

抽象化(Abstraction)角色：抽象化给出的定义，并保存一个对实现化对象的引用。

修正抽象化(Refined Abstraction)角色：扩展抽象化角色，改变和修正父类对抽象化的定义。

实现化(implementor)角色：这个角色给出实现化角色的接口，但不给出具体的实现。这个接口不一定和抽象化角色定义相同的接口、实现化角色应当只给出低层操作，而抽象化角色应当只给出基于低层操作的更高一层的操作。

具体实现化角色：这个角色给出实现化角色接口的具体实现。

代码如下：

package cn.qlq.bridge;

public abstract class Implementor {

    public abstract void operationImpl();
}

package cn.qlq.bridge;

public class ConcreteImplementorA extends Implementor {

    @Override
    public void operationImpl() {
        System.out.println(" ConcreteImplementorA operationImpl ");
    }

}

package cn.qlq.bridge;

public class ConcreteImplementorB extends Implementor {

    @Override
    public void operationImpl() {
        System.out.println(" ConcreteImplementorB operationImpl ");
    }

}

package cn.qlq.bridge;

public class Abstraction {

    private Implementor implementor;

    public void operation() {
        if (implementor != null) {
            implementor.operationImpl();
        }
    }

    public Implementor getImplementor() {
        return implementor;
    }

    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }

}

package cn.qlq.bridge;

public class RefinedAbstraction extends Abstraction {

    @Override
    public void operation() {
        // 增强逻辑
    }

}

2.  桥接模式的例子

　　一个例子: 手机有多种品牌，又有不同的软件。

(1)不采用桥接模式：

　　如果需要增加一个MP3音乐播放器。做法就是在手机品牌M和手机品牌N下面都增加一个子类，但是这两个子类的差别可能并不大。

　　如果需要增加一个品牌L更加复杂，需要增加一个类手机品牌L继承手机品牌，并且还需要两个子类手机品牌L通讯录和手机品牌L游戏并继承手机品牌L。

(2)采用桥接模式的设计如下：

　　一个抽象"手机品牌"和抽象类"手机软件",不同的品牌和不同的软件分别继承于他们。手机品牌包含有手机软件，但是手机软件并不是品牌的一部分，所以他们之间是聚合关系。

代码如下：

package cn.qlq.bridge.example.plain;

import java.util.List;

/**
 * 抽象手机品牌
 *
 * @author Administrator
 *
 */
public abstract class HandsetBrand {

    protected List<HandsetSoft> handsetSofts;

    public HandsetBrand(List<HandsetSoft> handsetSofts) {
        super();
        this.handsetSofts = handsetSofts;
    }

    abstract void run();

}

package cn.qlq.bridge.example.plain;

import java.util.List;

/**
 * 手机品牌M
 *
 * @author Administrator
 *
 */
public class HandsetBrandM extends HandsetBrand {

    public HandsetBrandM(List<HandsetSoft> handsetSofts) {
        super(handsetSofts);
    }

    @Override
    void run() {
        for (HandsetSoft handsetSoft : handsetSofts) {
            handsetSoft.run();
        }
    }

}

package cn.qlq.bridge.example.plain;

import java.util.List;

/**
 * 手机品牌N
 *
 * @author Administrator
 *
 */
public class HandsetBrandN extends HandsetBrand {

    public HandsetBrandN(List<HandsetSoft> handsetSofts) {
        super(handsetSofts);
    }

    @Override
    void run() {
        for (HandsetSoft handsetSoft : handsetSofts) {
            handsetSoft.run();
        }
    }

}

package cn.qlq.bridge.example.plain;

/**
 * 手机软件
 *
 * @author Administrator
 *
 */
public abstract class HandsetSoft {

    abstract void run();
}

package cn.qlq.bridge.example.plain;

/**
 * 手机游戏
 *
 * @author Administrator
 *
 */
public class HandsetGame extends HandsetSoft {

    @Override
    void run() {
        System.out.println("手机游戏");
    }

}

package cn.qlq.bridge.example.plain;

public class HandsetAddressList extends HandsetSoft {

    @Override
    void run() {
        System.out.println("手机通讯录");
    }

}

这时候如果增加一个功能，只需要增加一个类：

package cn.qlq.bridge.example.plain;

public class HandsetMP3 extends HandsetSoft {

    @Override
    void run() {
        System.out.println("mp3");
    }

}

如果需要增加一个新品牌L，也是增加一个类：

package cn.qlq.bridge.example.plain;

import java.util.List;

/**
 * 手机品牌L
 *
 * @author Administrator
 *
 */
public class HandsetBrandL extends HandsetBrand {

    public HandsetBrandL(List<HandsetSoft> handsetSofts) {
        super(handsetSofts);
    }

    @Override
    void run() {
        for (HandsetSoft handsetSoft : handsetSofts) {
            handsetSoft.run();
        }
    }

}

3.  桥接模式适用场景

　　如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。

　　设计要求实现化角色的任何改变不影响客户端，或者实现化角色的改变对客户端是完全透明的。

　　一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态解耦。

　　虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。

 总结：

　　上面的设计也符合开闭原则。相比聚合，继承更容易造成不必要的麻烦。在使用继承时，一定要在"is - a" 关系的时候再考虑使用。

　　由于上面的两个抽象类之间有一个聚合的关系箭头，有一条聚合线，这么理解更容易记住 桥接 模式。