设计模式学习笔记——桥梁模式

定义：

将抽象和实现解耦，使得两者可以独立地变化。（抽象角色引用实现角色，实现抽象角色的部分实现）

 

桥接模式主要是为了补充继承的缺点的，继承有什么缺点呢？即强侵入，父类有这个方法，子类也必须有这个方法，这是不可选择的，会带来扩展性的问题。比如A类有一个方法，B类继承了A类的这个方法，C类继承了B类的这个方法，如果B类要重写父类的这个方法，那么它就要修改和C类的关系，这就带来了很大的风险。

通用类图如下：



代码：

//抽象化角色
public abstract class Abstraction {
private Implementor implementor;

//这里在抽象类中增加了一个构造函数，是为了提醒子类，尽量明确的指定实现者
public Abstraction(Implementor implementor) {
this.implementor = implementor;
}

public Implementor getImplementor() {
return implementor;
}

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

//自身的属性和行为
public void request(){
this.implementor.doSomething();
}
}
//抽象化角色的具体实现
public class ConcreteAbstraction1 extends Abstraction{

public ConcreteAbstraction1(Implementor implementor) {
super(implementor);
}

//重写父类的行为
@Override
public void request() {
super.request();
super.getImplementor().doAnything();
}
}

//抽象化角色的具体实现
public class ConcreteAbstraction2 extends Abstraction{

public ConcreteAbstraction2(Implementor implementor) {
super(implementor);
}

//重写父类的行为
@Override
public void request() {
// TODO Auto-generated method stub
super.request();
super.getImplementor().doAnything();
}
}

//实现类的接口
public interface Implementor {
public void doSomething();
public void doAnything();
}

public class ConcreteImpl1 implements Implementor {

@Override
public void doSomething() {
System.out.println("1 do some thing...");
}

@Override
public void doAnything() {
System.out.println("1 do any thing...");
}

}

public class ConcreteImpl2 implements Implementor {

@Override
public void doSomething() {
System.out.println("2 do some thing...");
}

@Override
public void doAnything() {
System.out.println("2 do any thing...");
}

}

public class Client {
public static void main(String[] args) {
Implementor implementor2=new ConcreteImpl2();
Abstraction abs=new ConcreteAbstraction2(implementor2);

abs.request();

Implementor implementor1=new ConcreteImpl1();
Abstraction abs1=new ConcreteAbstraction2(implementor1);

abs1.request();
}
}

桥梁模式的优点：

1、  抽象和实现分离

实现可以完全不受抽象的约束，不用再绑定在一个固定的抽象层次上，解决了继承的缺点。

2、优秀的扩展能力

         抽象和实现都可以独立的进行扩展。

3、  实现细节对客户的透明

客户不用关心细节的实现，它已经通过抽象层通过聚合关系完成了封装。

 

桥梁模式的使用场景：

1、  不希望或不使用使用继承的场景，例如继承层次过度，无法更细化设计颗粒；

2、抽象或接口不稳定的场景；

3、重用性要求较高的场景，设计的颗粒度越细，则被重用的可能性就越大，而采用继承则受父类的限制，不可能出现太细的颗粒度。