java设计模式之桥接模式

一、概述

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

二、适用性

1.你不希望在抽象和它的实现部分之间有一个固定的绑定关系。 例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。

2.类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。 这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。 

3.对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。 

4.正如在意图一节的第一个类图中所示的那样，有许多类要生成。 这样一种类层次结构说明你必须将一个对象分解成两个部分。 5.你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。

三、参与者

1.Abstraction 

       定义抽象类的接口。 维护一个指向Implementor类型对象的指针。 

2.RefinedAbstraction 

      扩充由Abstraction定义的接口。 

3.Implementor

      定义实现类的接口，该接口不一定要与Abstraction的接口完全一致。 事实上这两个接口可以完全不同。 一般来讲，Implementor接口仅提供基本操作，而Abstraction则定义了基于这些基本操作的较高层次的操作。

4.ConcreteImplementor

     实现Implementor接口并定义它的具体实现。

四、类图

代码实现如下：

Abstraction

package com.deppon.tps.module.TestBridgePattern;

public interface Sourceable {
void method();
}

RefinedAbstraction

package com.deppon.tps.module.TestBridgePattern;

public class SourceSub1 implements Sourceable{
@Override
public void method() {
System.out.println("this is the first sub!");
}
}

package com.deppon.tps.module.TestBridgePattern;

public class SourceSub2 implements Sourceable{
@Override
public void method() {
System.out.println("this is the sencond sub!");
}
}

Implementor

package com.deppon.tps.module.TestBridgePattern;
public class Bridge {
private Sourceable source;
public void method(){
source.method();
}
public Sourceable getSource() {
return source;
}
public void setSource(Sourceable source) {
this.source = source;
}
}

ConcreteImplementor

package com.deppon.tps.module.TestBridgePattern;
public class MyBridge extends Bridge{
public void method(){
getSource().method();
}
}

TEST

package com.deppon.tps.module.TestBridgePattern;
public class Test {
public static void main(String[] arg){
MyBridge myBridge=new MyBridge();
/*调用第一个对象*/
Sourceable source1 = new SourceSub1();
myBridge.setSource(source1);
myBridge.method();
/*调用第二个对象*/
Sourceable source2 = new SourceSub2();
myBridge.setSource(source2);
myBridge.method();
}
}

结果：

this is the first sub!

this is the sencond sub!

这样，就通过对Bridge类的调用，实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用，接下来我再画个图，大家就应该明白了，因为这个图是我们JDBC连接的原理，有数据库学习基础的，一结合就都懂了。



jdbc桥连接过程解析：详见：http://blog.csdn.net/paincupid/article/details/43614029

五、二维度的

 桥接模式的做法是把变化部分抽象出来，使变化部分与主类分离开来，从而将多个维度的变化彻底分离。最后，提供一个管理类来组合不同维度上的变化，通过这种组合来满足业务的需要。

举个例子,对于笔记本的CPU评测,当安装Intel CPU的时候 评测分数比较高,而安装AMD CPU的时候，则评测分数相对低一些,这个是一唯影响,而配合上电脑品牌,就是二维影响

package com.deppon.tps.module.TestBridgePattern.example1;
public interface CpuAbility {
String abilityCpu();
}

package com.deppon.tps.module.TestBridgePattern.example1;

public class InteCpu implements CpuAbility{
@Override
public String abilityCpu() {
return "系统比较好啦";
}
}

package com.deppon.tps.module.TestBridgePattern.example1;

public class AmdCpu implements CpuAbility{
@Override
public String abilityCpu() {
return "性能一般啦";
}
}

package com.deppon.tps.module.TestBridgePattern.example1;

public class AbstractComputer {
CpuAbility cpuAbility;
public AbstractComputer(CpuAbility cpuAbility){
this.cpuAbility=cpuAbility;
}
public void checkPcAbility(){
}
}

package com.deppon.tps.module.TestBridgePattern.example1;

public class LenevoComputer extends AbstractComputer {
public LenevoComputer(CpuAbility cpuAbility) {
super(cpuAbility);
// TODO Auto-generated constructor stub
}
public void checkPcAbility(){
System.out.println("联想笔记本CPU性能"+super.cpuAbility.abilityCpu());
}
}

package com.deppon.tps.module.TestBridgePattern.example1;

public class IswComputer extends AbstractComputer{
public IswComputer(CpuAbility cpuAbility) {
super(cpuAbility);
}
public void checkPcAbility(){
System.out.println("华硕笔记本CPU性能"+super.cpuAbility.abilityCpu());
}
}

package com.deppon.tps.module.TestBridgePattern.example1;

public class Test {
public static void main(String[] arg){
CpuAbility cpuAbility=new InteCpu();
LenevoComputer lenevoComputer=new LenevoComputer(cpuAbility);
lenevoComputer.checkPcAbility();

CpuAbility AmdAbility=new AmdCpu();
IswComputer iswComputer=new IswComputer(AmdAbility);
iswComputer.checkPcAbility();

}
}

结果:

联想笔记本CPU性能系统比较好啦

华硕笔记本CPU性能性能一般啦

可以看到，通过对象组合的方式，Bridge 模式把两个角色之间的继承关系改为了耦合的关系，从而使这两者可以从容自若的各自独立的变化，这也是Bridge模式的本意。

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