句话

将抽象和行为划分开来 , 各自独立 , 但能动态的组合。
结构图
图 1 Bridge 模式结构图
生活中的例子
比如，一杯咖啡为例 , 子类实现类为四个：中杯加奶、大杯加奶、 中杯不加奶、大杯不加奶。这四个类实际是两个角色的组合：抽象 和行为，其中抽象为：中杯和大杯；行为为：加奶 不加奶（如加橙汁 加苹果汁）， 这就是 Bridge 模式。
桥接模式解说
以上面提到的咖啡 为例. 我们原来打算只设计一个接口(抽象类),使用Bridge模式后,我们需要将抽象和行为分开,加奶和不加奶属于行为,我们将它们抽象成一个专门的行为接口.
先看看抽象部分的接口代码:

public abstract class Coffee
{
 　　CoffeeImp coffeeImp;

　　public void setCoffeeImp() {
　　　　this.CoffeeImp = CoffeeImpSingleton.getTheCoffeImp();
　　}

　　public CoffeeImp getCoffeeImp() {return this.CoffeeImp;}

　　public abstract void pourCoffee();
}

其中CoffeeImp 是加不加奶的行为接口,看其代码如下:

public abstract class CoffeeImp
{
 　　public abstract void pourCoffeeImp();
}

现在我们有了两个抽象类,下面我们分别对其进行继承:

// 中杯
public class MediumCoffee : Coffee
{
　　public MediumCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
// 这里加入了行为，到底是加奶还是加柠檬，由coffeeImp决定
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯还是大杯 ,重复2次是中杯
　　　　for (int i = 0; i < 2; i++)
　　　　{
　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}
// 大杯
public class SuperSizeCoffee : Coffee
{
　　public SuperSizeCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
// 这里加入了行为，到底是加奶还是加柠檬，由coffeeImp决定
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯还是大杯 ,重复5次是大杯
　　　　for (int i = 0; i < 5; i++)
　　　　{
　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}

上面分别是中杯和大杯的具体实现.下面再对行为CoffeeImp进行继承:

// 加奶
public class MilkCoffeeImp : CoffeeImp
{
　　MilkCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　//"加了美味的牛奶"
　　}
}
// 不加奶
public class FragrantCoffeeImp : CoffeeImp
{
　　FragrantCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　//"什么也没加,清香"
　　}
}

Bridge 模式的基本框架我们已经搭好了,别忘记定义中还有一句:动态结合,我们现在可以喝到至少四种咖啡:
1.中杯加奶
2.中杯不加奶
3.大杯加奶
4.大杯不加奶
看看是如何动态结合的,在使用之前,我们做个准备工作,设计一个单件类(Singleton)用来加载当前的CoffeeImp:

public class CoffeeImpSingleton
{
 　　private static CoffeeImp coffeeImp;

　　public CoffeeImpSingleton(CoffeeImp coffeeImpIn)
　　 {this.coffeeImp = coffeeImpIn;}

　　public static CoffeeImp getTheCoffeeImp()
　　{
　　　　return coffeeImp;
　　}
}

看看中杯加奶 和大杯加奶 是怎么出来的:
// 拿出牛奶
CoffeeImpSingleton coffeeImpSingleton = new CoffeeImpSingleton(new MilkCoffeeImp());

//中杯加奶
MediumCoffee mediumCoffee = new MediumCoffee();
mediumCoffee.pourCoffee();

//大杯加奶
SuperSizeCoffee superSizeCoffee = new SuperSizeCoffee();
superSizeCoffee.pourCoffee();
注意: Bridge模式的执行类如CoffeeImp和Coffee是一对一的关系, 正确创建CoffeeImp是该模式的关键.
为了体现Bridge 模式的优点，我们再加一个抽象（小杯）和再加一个行为（加柠檬）
// 小杯
public   class  SmallCoffee : Coffee
 {
　　public SmallCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
//这里加入了行为，到底是加奶还是加柠檬，由coffeeImp决定
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//重复1次是小杯
　　　　for (int i = 0; i < 1; i++)
　　　　{
　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　}
}

 
// 加柠檬
public   class  LemonCoffeeImp : CoffeeImp
 {
　　LemonCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　//"加柠檬"
　　}
}

// 拿出柠檬
CoffeeImpSingleton coffeeImpSingleton  =   new  CoffeeImpSingleton( new  LemonCoffeeImp ());


//小杯加柠檬


使用Bridge桥接模式的《杯子加料》的uml图

  如果不使用 Bridge 模式，一般的解决方案是这样的
 
 
 
效果及实现要点
1 ． Bridge 模式使用“对象间的组合关系”解耦了抽象和行为之间固有的绑定关系，使得抽象和行为可以沿着各自的维度来变化。
2 ．所谓抽象和行为沿着各自维度的变化，即“子类化”它们，得到各个子类之后，便可以任意它们，从而获得不同平台上的不同型号。
3 ． Bridge 模式有时候类似于多继承方案，但是多继承方案往往违背了类的单一职责原则（即一个类只有一个变化的原因），复用性比较差。 Bridge 模式是比多继承方案更好的解决方法。
4 ． Bridge 模式的应用一般在“两个非常强的变化维度”，有时候即使有两个变化的维度，但是某个方向的变化维度并不剧烈——换言之两个变化不会导致纵横交错的结果，并不一定要使用 Bridge 模式。
适用性
在以下的情况下应当使用桥梁模式：
1 ．如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。
2 ．设计要求行为化角色的任何改变不应当影响客户端，或者说行为化角色的改变对客户端是完全透明的。
3 ．一个构件有多于一个的抽象化角色和行为化角色，系统需要它们之间进行动态耦合。
4 ．虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。
总结
Bridge 模式是一个非常有用的模式，也非常复杂，它很好的符合了开放 - 封闭原则和优先使用对象，而不是继承这两个面向对象原则。目前有一种流行的设计模式，个人认为它来源与 Bridge 的创意，它就是IoC，它的大名鼎鼎的容器是Spring.