设计模式之桥梁模式

桥梁模式的定义

桥梁模式（Bridge Pattern）也叫做桥接模式，是一个比较简单的模式，其定义如下: Decouple an abstraction from its implementation so that the two can very independently. 即：将抽象和实现解耦，使得两者可以独立的变化。
  桥梁模式的重点在于解耦，通用类图如下：

Bridge.png

我们先看看桥梁模式的四个角色：

• Abstraction 抽象角色。抽象角色主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类。
• Implementor 实现化角色。抽象类或接口，定义角色必须的行为和属性。
• RefinedAbstraction 修正抽象化角色。引用实现化角色对抽象化角色进行修正。
• ConcreteImplementor 具体实现化角色。
  桥梁模式的通用代码如下:

//实现化角色
public interface Implementor{
    //基本方法
    public void doSomething();
    public void doAnything();
}

//具体实现化角色
public class ConcreteImplementor1 implements Implementor{

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

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

//具体实现化角色
public class ConcreteImplementor2 implements Implementor{
    
    @Override
    public void doSomething() {
        System.out.println("ConcreteImplementor 2 doSomething...");
    }
    
    @Override
    public void doAnything() {
        System.out.println("ConcreteImplementor 2 doAnything...");
    }
    
}

//抽象化角色
public abstract class Abstraction{
    //定义对实现化角色的引用
    private Implementor impl;
    //约束子类必须实现构造函数
    public Abstraction(Implementor impl){
        this.impl = impl;
    }
    
    //自身的行为和属性。
    public void request(){
        this.impl.doSomething();
    }
    
    //获得实现化角色
    public Implementor getImplementor(){
        return this.impl;
    }
}

//具体抽象化角色
public class RefinedAbstraction extends Abstraction{

    public RefinedAbstraction(Implementor impl) {
        super(impl);
    }
    
    //修正父类行为
    @Override
    public void request(){
        super.request();
        super.getImplementor().doAnything();
    }
    
}

//客户端
public class BridgeClient{ 
    public static void main(String[] args) {
        //定义一个实现化角色
        Implementor impl1 = new ConcreteImplementor1();
        //定义一个抽象化角色
        Abstraction abs1 = new RefinedAbstraction(impl1);
        //执行
        abs1.request();
        System.out.println("------------------------");
        //定义一个实现化角色
        Implementor impl2 = new ConcreteImplementor2();
        //定义一个抽象化角色
        Abstraction abs2 = new RefinedAbstraction(impl2);
        //执行
        abs2.request();
    }
}

通用代码运行结果如下：

ConcreteImplementor 1 doSomething...
ConcreteImplementor 1 doAnything...
------------------------
ConcreteImplementor 2 doSomething...
ConcreteImplementor 2 doAnything...

桥梁模式的应用

桥梁模式的优点

• 抽象和实现分离。为了解决继承的缺点而提出的设计模式，在该模式下，实现可以不受抽象的约束，不用再绑定在一个固定的抽象层次上。
• 优秀的扩充能力。
• 实现细节对客户透明。

桥梁模式使用场景

• 不希望或不适用继承的场景。
• 抽象类或接口不稳定的场景。
• 重用性比较高的场景。

《注》以上内容总结自秦小波-《设计模式之禅》，仅为个人学习笔记