Java实现桥接模式（设计模式 五）

桥接模式是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化，桥接模式通过提供一个桥接接口，将抽象类与具体实现类解耦，使它们可以独立地进行扩展。

基本设计流程如下

1. 定义抽象类或接口，作为实现的桥接点

// 实现的桥接点接口
interface Implementor {
    //原始功能
    void operationImpl();
}

 2. 创建抽象部分的抽象类或接口

创建抽象类或接口，抽象部分的接口应该包含对实现部分的引用，并定义抽象方法。

// 抽象类(抽象部分)
abstract class Abstraction {
    //原始功能引用(桥接抽象部分和实现部分的关键)
    protected Implementor implementor;
 
    protected Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }
 
    //扩展的新功能(抽象部分)
    abstract void operation();
}

3. 创建实现部分的具体实现类

根据实现部分的接口，创建具体的实现类。每个具体实现类负责实现实现部分的接口。

// 具体实现类A
class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("原始功能A");
    }
}
 
// 具体实现类B
class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("原始功能B");
    }
}

4. 创建抽象部分的具体扩展类

每个具体扩展类继承自抽象部分的抽象类或实现抽象部分的接口，并实现抽象方法。在具体扩展类的方法中，调用实现部分的方法，以实现抽象部分和实现部分的交互。

// 具体实现类A的扩展(抽象部分扩展类)
class RefinedAbstractionA extends Abstraction {
    //构建含有原始功能的引用
    protected RefinedAbstractionA(Implementor implementor) {
        super(implementor);
    }
 
    //添加的新功能
    @Override
    void operation() {
        System.out.println("扩展原始A的操作");
//      super.implementor.operationImpl();
        //同时实现原始功能
        implementor.operationImpl();
    }
}
 
// 具体实现类B的扩展((抽象部分扩展类))
class RefinedAbstractionB extends Abstraction {
    protected RefinedAbstractionB(Implementor implementor) {
        super(implementor);
    }
 
    @Override
    void operation() {
        System.out.println("扩展原始功能B的操作");
        implementor.operationImpl();
    }
}

5. 使用桥接模式进行测试

创建具体实现类的实例，并将其传递给具体扩展类的构造函数，然后，调用具体扩展类的方法，触发抽象部分和实现部分的交互。

public class Main {
    public static void main(String[] args) {
        //原始实现类对象
        Implementor implementorA = new ConcreteImplementorA();
        Implementor implementorB = new ConcreteImplementorB();
 
        //同时实现两个功能A(抽象部分和实现部分)
        Abstraction abstractionA = new RefinedAbstractionA(implementorA);
        abstractionA.operation();
 
        System.out.println("------------------------------------");
 
        //同时实现两个功能B(抽象部分和实现部分)
        Abstraction abstractionB = new RefinedAbstractionB(implementorB);
        abstractionB.operation();
    }
}
 
    /* 结果如下
    扩展原始A的操作
    原始功能A
    ------------------------------------
    扩展原始功能B的操作
    原始功能B
    */