设计模式-桥梁模式

1.桥梁模式的定义及使用场景

定义：

桥梁模式也称为桥接模式，是结构型设计模式之一。将抽象和实现解耦，使得两者可以独立地变化

使用场景：

• 不希望或不适合使用继承的场景
  例如继承层次过渡、无法更细化设计颗粒等场景，而要考虑使用桥梁模式
• 接口或抽象类不稳定的场景
  明知道接口不稳定还想通过实现或继承来实现业务需求，那是得不偿失，也是比较失败的做法
• 重用性要求较高的场景

2. 桥梁模式的优缺点

2.1优点

• 抽象和实现分离
  这也是桥梁模式的主要特点，它完全是为了解决继承的缺点而提出的设计模式。在该模式下，实现可以不受抽象的约束，不用再绑定一个固定的抽象层次上
• 优秀的扩充能力
• 实现细节对客户透明
  客户不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装

2.2缺点

良好的设计不易，对开发者来说要有一定的经验要求，原因是对于抽象和实现的分离需要有良好的把握。

3.注意事项

桥梁模式是非常简单的，使用该模式时注意考虑如何拆分抽象和实现，并不是一涉及继承就要考虑使用该模式，那还要继承干什么呢？桥梁模式的意图还是对变化的封装，尽量把可能变化的因素封装到最细、最小的逻辑单元中，避免风险扩散。因此在进行系统涉及是，发现类的继承有N层时，可以考虑使用桥梁模式。

4. 桥梁模式的实现方式

public interface Implementor {
    //基本方法
    public void doSomething();
    public void doAnything();
}

public class ConcreteImplementor1 implements Implementor {
    @Override
    public void doSomething() {
        System.out.println("ConcreteImplementor1 doSomething!");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteImplementor1 doAnything!");
    }
}

public class ConcreteImplementor2 implements Implementor {
    @Override
    public void doSomething() {
        System.out.println("ConcreteImplementor2 doSomething!");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteImplementor2 doAnything!");
    }
}

public abstract class Abstraction {
    //定义对实现化角色的引用
    private Implementor imp;

    //约束子类必须实现该构造函数
    public Abstraction(Implementor imp) {
        this.imp = imp;
    }

    //自身的行为和属性
    public void request() {
        this.imp.doSomething();
    }

    public Implementor getImp() {
        return imp;
    }
}

public class RefineAbstraction extends Abstraction {

    public RefineAbstraction(Implementor imp) {
        super(imp);
    }

    @Override
    public void request() {
        /**
         * 业务处理
         */
        super.request();
        super.getImp().doAnything();
    }
}

public class Test {
    public static void main(String args[]) {
        Implementor imp = new ConcreteImplementor1();
        Abstraction abstraction = new RefineAbstraction(imp);
        abstraction.request();

        Implementor imp2 = new ConcreteImplementor2();
        abstraction = new RefineAbstraction(imp2);
        abstraction.request();
    }
}