簡明設計模式---橋接模式

語言: CN / TW / HK

簡述

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

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

優化案例

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

最初版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 持有 RadiusColorShadow ,並且根據構造時傳入的具體實現動態的更改持有的具體實現。易用性上也有著提升。

總結

優點

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

缺點

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

適用場景

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