原文:http://blog.youkuaiyun.com/hackerain/article/details/7589146
定义:
将抽象和实现解耦,使得两者可以独立地变化。(抽象角色引用实现角色,实现抽象角色的部分实现)
桥接模式主要是为了补充继承的缺点的,继承有什么缺点呢?即强侵入,父类有这个方法,子类也必须有这个方法,这是不可选择的,会带来扩展性的问题。比如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、重用性要求较高的场景,设计的颗粒度越细,则被重用的可能性就越大,而采用继承则受父类的限制,不可能出现太细的颗粒度。
桥梁模式注意事项
桥梁模式的意图还是对变化的封装,尽量把可能变化的因素封装到最细、最小的逻辑单元中,避免风险扩散。进行系统设计时,发现类的继承有N层时,可以考虑使用桥梁模式。
对于比较明确不发生变化的,则通过继承来完成,若不能确定是否会发生变化,那就认为是会发生变化,则通过桥梁模式来解决。