設計模式---橋接模式

簡述

型別：結構型
目的：通過抽離出多個維度相互組合(聚合)來代替繼承，簡化系統。

話不多說，看個優化案例。

優化案例

現有系統中，對於畫面視窗的邊框有一套樣式來控制是否有圓角。因為新的需求，需要增加兩套樣式，一套控制邊框線條的顏色(紅、黃、藍)，一套控制邊框有無陰影。我們來看看幾種實現方式。

最初版v0

我們看看用繼承或實現的方式，會是什麼樣子。

interface Style {
    void style();
}
class Radius implements style {
    public void style() {
        radius();
    }
    protected void radius() {
        System.out.println("有邊框圓角");
    }
}
class RadiusRed extends Radius {
    public void style() {
        super.style();
        this.red();
    }
    protected void red() {
        System.out.println("紅色邊框");
    }
}
class RadiusBlue extends Radius {
    public void style() {
        super.style();
        this.blue();
    }
    protected void blue() {
        System.out.println("藍色邊框");
    }
}
class RadiusYellow extends Radius {
    public void style() {
        super.style();
        this.yellow();
    }
    protected void yellow() {
        System.out.println("黃色邊框");
    }
}
class RadiusRedShadow extends RadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("有邊框陰影");
    }
}
class RadiusBlueShadow extends RadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("有邊框陰影");
    }
}
class RadiusYellowShadow extends RadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("有邊框陰影");
    }
}
class RadiusRedNotShadow extends RadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("無邊框陰影");
    }
}
class RadiusBlueNotShadow extends RadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("無邊框陰影");
    }
}
class RadiusYellowNotShadow extends RadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("無邊框陰影");
    }
}
class NotRadius implements style {
    public void style() {
        radius();
    }
    protected void radius() {
        System.out.println("無邊框圓角");
    }
}
class NotRadiusRed extends NotRadius {
    public void style() {
        super.style();
        this.red();
    }
    protected void red() {
        System.out.println("紅色邊框");
    }
}
class NotRadiusBlue extends NotRadius {
    public void style() {
        super.style();
        this.blue();
    }
    protected void blue() {
        System.out.println("藍色邊框");
    }
}
class NotRadiusYellow extends NotRadius {
    public void style() {
        super.style();
        this.yellow();
    }
    protected void yellow() {
        System.out.println("黃色邊框");
    }
}
class NotRadiusRedShadow extends NotRadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("邊框陰影");
    }
}
class NotRadiusBlueShadow extends NotRadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("邊框陰影");
    }
}
class NotRadiusYellowShadow extends NotRadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("邊框陰影");
    }
}
class NotRadiusRedNotShadow extends NotRadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("無邊框陰影");
    }
}
class NotRadiusBlueNotShadow extends NotRadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("無邊框陰影");
    }
}
class NotRadiusYellowNotShadow extends NotRadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("無邊框陰影");
    }
}

可以看出，使用實現或者繼承的方式來構件模組所需的類的數量及其的龐大(21個)。寫吐了，太多太繁瑣了。
再看看使用者端的使用方法。

class Client {
    public static void main(String[] args) {
        Style style = new NotRadiusYellowNotShadow();
        style.style();
    }
}

使用者端的使用還是比較簡單的，但這並不能掩蓋類的數量過多的問題。

那麼除了這種方法，我們還有什麼別的更好的辦法可以實現嗎？當然有了。

修改版v1

引入橋接模式，優化多維度繼承問題。
首先，我們得分析這個模組。模組中有三種不同的維度(Radius,Color,Shadow)，都是用來拓展Style的。將三個維度都抽象成介面，並且將Style定義為橋接類。我們看看新的程式碼。

interface Radius {
    void radius();
}
interface Color {
    void color();
}
interface Shadow {
    void shadow();
}
class HasRadius implements Radius {
    public void radius() {
        System.out.println("有邊框圓角");
    }
}
class HasNotRadius implements Radius {
    public void radius() {
        System.out.println("無邊框圓角");
    }
}
class Red implements Color {
    public void color() {
        System.out.println("紅色邊框");
    }
}
class Yellow implements Color {
    public void color() {
        System.out.println("黃色邊框");
    }
}
class Blue implements Color {
    public void color() {
        System.out.println("藍色邊框");
    }
}
class HasShadow implements Shadow {
    public void shadow() {
        System.out.println("有邊框陰影");
    }
}
class HasNotShadow implements Shadow {
    public void shadow() {
        System.out.println("無邊框陰影");
    }
}
class Style {
    private Radius radius;
    private Color color;
    private Shadow shadow;
    public Style(Radius radius, Color color, Shadow shadow) {
        this.radius = radius;
        this.color = color;
        this.shadow = shadow;
    }
    public void init() {
        radius.radius();
        color.color();
        shadow.shadow();
    }
}

類的數量急劇減少，而且如果三個維度中有新的Style增加，也只需要在對應的維度增加新的實現類即可。即便增加新的維度，也只需要對應增加一套介面和實現類。最多在橋接類Style中增加持有的介面物件即可(雖然不符合開閉原則)。

我們再來看看使用者端的使用方法。

class Client {
    public static void main(String[] args) {
        Style style = new Style(new HasRadius(), new Red(), new HasShadow());
        style.init();
    }
}

Style持有Radius，Color，Shadow，並且根據構造時傳入的具體實現動態的更改持有的具體實現。易用性上也有著提升。

總結

優點

通過聚合或組合替代傳統的繼承方案。
提高了系統的可拓展性，每個維度增加新的是實現或者增加新的維度，對原有系統無影響。

缺點

增加系統的理解和設計難度，需要面向抽象程式設計。
需要預先確定正確的維度。看問題的角度不同得到的結果也不同，這個維度也是一樣的，作為乙方想到的維度很有可能不是甲方預想的維度，所以這個維度的確認竟可能在功能實現前找客戶確認完成之後決定。

適用場景

可以抽象出多個維度的功能組合的類設計的場景。