桥接模式

Bridge Patterns

GoF定义：将抽象定义和其实现分离，达到解耦的目的

概念

在此模式中，将抽象类和它的实现类实现的接口分离。并且在它们之间提供一个桥接接口（bridge interface）。这个接口帮助我们使实现类的功能和接口的功能相独立。我们可以在不互相影响这些类的情况下进行结构性的互相替代

例子

现实世界：在软件开发公司中，开发团队和技术支持部门都很重要。当其中一个团队的运营策略之后不应该对其它团队有影响。这里技术支持团队的角色就是客户和开发团队之间的沟通桥梁
代码世界：GUI框架中使用了这个模式。将Linux/Mac OS中窗口的抽象和窗口的实现分离

展示

在上述情况下做修正

代码

public class BridgePatternEx {
    public static void main(String[] args) {
        System.out.println("*****BRIDGE PATTERN*****");
        //Coloring Green to Triangle
        System.out.println("\nColoring Triangle:");
        IColor green = new GreenColor();
        Shape triangleShape = new Triangle(green);
        triangleShape.drawShape(20);
        triangleShape.modifyBorder(20, 3);
        //Coloring Red to Rectangle
        System.out.println("\n\nColoring Rectangle :");
        IColor red = new RedColor();
        Shape rectangleShape = new Rectangle(red);
        rectangleShape.drawShape(50);
        //Modifying the border length twice
        rectangleShape.modifyBorder(50,2);
    }
}

interface IColor {
    void fillWithColor(int border);
}

class RedColor implements IColor {
    @Override
    public void fillWithColor(int border) {
        System.out.print("Red color with " +border+" inch border");
    }
}

class GreenColor implements IColor {
    @Override
    public void fillWithColor(int border) {
        System.out.print("Green color with " +border+" inch border.");
    }
}

abstract class Shape {
    protected IColor iColor;

    public Shape(IColor iColor) {
        this.iColor = iColor;
    }

    abstract void drawShape(int border);
    abstract void modifyBorder(int border, int increment);
}

class Triangle extends Shape {

    public Triangle(IColor iColor) {
        super(iColor);
    }

    // implementer-specific method
    @Override
    void drawShape(int border) {
        System.out.print("This Triangle is colored with: ");
        iColor.fillWithColor(border);
    }

    // abstraction-specific method
    @Override
    void modifyBorder(int border, int increment) {
        System.out.println("\nNow we are changing the border length "+increment+ " times");
        border=border*increment;
        drawShape(border);
    }
}

class Rectangle extends Shape {

    public Rectangle(IColor iColor) {
        super(iColor);
    }

    // implementer-specific method
    @Override
    void drawShape(int border) {
        System.out.print("This Rectangle is colored with: ");
        iColor.fillWithColor(border);
    }

    // abstraction-specific method
    @Override
    void modifyBorder(int border, int increment) {
        System.out.println("\nNow we are changing the border length "+increment+ " times");
        border=border*increment;
        drawShape(border);
    }
}

Note

1. 当我们的类和它相关联的功能频繁改变时可以使用这种模式（包含接口的类的代码是不需要变动的）
2. 这里把抽象和具体实现分开（每个Shape实现类不再实现IColor接口）。此时，本例中的继承层次是分离的，各自可以通过子类继续扩展
3. 实现类的抽象方法和接口方法互不干扰

Q&A

这个模式是不是一定应用于抽象类和接口？
不是，应用于任意有交错继承关系的结构，无论是抽象类和接口

什么叫做“refined abstractions”？
抽象类的子类

什么是“concrete implementers”？
实现接口的类

怎样从（接口）实现类中区分出抽象子类？
一般来说，抽象子类包含接口类型的引用

怎样在运行时动态改变接口实现类？
改变它实际引用的对象

思考

桥接模式就是为了不让一些具体子类去继承一个类并且实现一堆接口，这样的话所有接口的改变都会影响这个实现类，所以只是包含一个接口类型引用。而且正如上一节所有，分离之后接口和抽象类（或仅接口）可以各自扩展而互不影响