設計模式---橋接模式-有解無憂

簡述

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

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

優化案例

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

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

總結

優點

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

缺點

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

適用場景

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

本文來自博客園，作者：buzuweiqi，轉載請注明原文鏈接：https://www.cnblogs.com/buzuweiqi/p/16726589.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/509408.html

標籤：Java

上一篇：springboot中使用mybatisplus自帶插件實作分頁

下一篇：樹的結點查找和洗掉