橋接模式的定義與特點

橋接（Bridge）模式的定義如下：將抽象與實現分離，使它們可以獨立變化。它是用組合關係代替繼承關係來實現，從而降低了抽象和實現這兩個可變維度的耦合度。

通過上面的講解，我們能很好的感覺到橋接模式遵循了里氏替換原則和依賴倒置原則，最終實現了開閉原則，對修改關閉，對擴充套件開放。這裡將橋接模式的優缺點總結如下。

橋接（Bridge）模式的優點是：

• 抽象與實現分離，擴充套件能力強
• 符合開閉原則
• 符合合成複用原則
• 其實現細節對客戶透明

缺點是：由於聚合關係建立在抽象層，要求開發者針對抽象化進行設計與程式設計，能正確地識別出系統中兩個獨立變化的維度，這增加了系統的理解與設計難度。

橋接模式的結構與實現

可以將抽象化部分與實現化部分分開，取消二者的繼承關係，改用組合關係。

1. 模式的結構

橋接（Bridge）模式包含以下主要角色。

1. 抽象化（Abstraction）角色：定義抽象類，幷包含一個對實現化物件的引用。

2. 擴充套件抽象化（Refined Abstraction）角色：是抽象化角色的子類，實現父類中的業務方法，並通過組合關係調用實現化角色中的業務方法。

3. 實現化（Implementor）角色：定義實現化角色的介面，供擴充套件抽象化角色呼叫。

4. 具體實現化（Concrete Implementor）角色：給出實現化角色介面的具體實現。

package bridge;

public class BridgeTest {
    public static void main(String[] args) {
        Implementor imple = new ConcreteImplementorA();
        Abstraction abs = new RefinedAbstraction(imple);
        abs.Operation();
    }
}

//實現化角色
interface Implementor {
    public void OperationImpl();
}

//具體實現化角色
class ConcreteImplementorA implements Implementor {
    public void OperationImpl() {
        System.out.println("具體實現化(Concrete Implementor)角色被訪問");
    }
}

//抽象化角色
abstract class Abstraction {
    protected Implementor imple;

    protected Abstraction(Implementor imple) {
        this.imple = imple;
    }

    public abstract void Operation();
}

//擴充套件抽象化角色
class RefinedAbstraction extends Abstraction {
    protected RefinedAbstraction(Implementor imple) {
        super(imple);
    }

    public void Operation() {
        System.out.println("擴充套件抽象化(Refined Abstraction)角色被訪問");
        imple.OperationImpl();
    }
}
 

//例子

package bridge;

import org.w3c.dom.NodeList;

import javax.swing.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.awt.*;

public class BagManage {
    public static void main(String[] args) {
        Color color;
        Bag bag;
        color = (Color) ReadXML.getObject("color");
        bag = (Bag) ReadXML.getObject("bag");
        bag.setColor(color);
        String name = bag.getName();
        show(name);
    }

    public static void show(String name) {
        JFrame jf = new JFrame("橋接模式測試");
        Container contentPane = jf.getContentPane();
        JPanel p = new JPanel();
        JLabel l = new JLabel(new ImageIcon("src/bridge/" + name + ".jpg"));
        p.setLayout(new GridLayout(1, 1));
        p.setBorder(BorderFactory.createTitledBorder("女士皮包"));
        p.add(l);
        contentPane.add(p, BorderLayout.CENTER);
        jf.pack();
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

//實現化角色：顏色
interface Color {
    String getColor();
}

//具體實現化角色：黃色
class Yellow implements Color {
    public String getColor() {
        return "yellow";
    }
}

//具體實現化角色：紅色
class Red implements Color {
    public String getColor() {
        return "red";
    }
}

//抽象化角色：包
abstract class Bag {
    protected Color color;

    public void setColor(Color color) {
        this.color = color;
    }

    public abstract String getName();
}

//擴充套件抽象化角色：挎包
class HandBag extends Bag {
    public String getName() {
        return color.getColor() + "HandBag";
    }
}

//擴充套件抽象化角色：錢包
class Wallet extends Bag {
    public String getName() {
        return color.getColor() + "Wallet";
    }
}
package bridge;
        import javax.xml.parsers.*;
        import org.w3c.dom.*;
        import java.io.*;

class ReadXML {
    public static Object getObject(String args) {
        try {
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/bridge/config.xml"));
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = null;
            if (args.equals("color")) {
                classNode = nl.item(0).getFirstChild();
            } else if (args.equals("bag")) {
                classNode = nl.item(1).getFirstChild();
            }
            String cName = "bridge." + classNode.getNodeValue();
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}