橋接模式

時間 2019-11-17

標籤橋接模式简体版

原文原文鏈接

橋接模式

橋接模式的用意是「將抽象化和實現化解耦，使兩者能夠獨立變化」。ide

抽象化：

存在於多個實體中的共同的概念性聯繫就是抽象化。抽象化把不一樣的實體當作一樣的實體對待。spa

實現化：

抽象化給出的具體實現就是實現化。類的實例是類的實現化，子類是抽象超類的實現化。code

解耦：

耦合就是兩個實體的行爲存在強關聯。去掉強關聯就是解耦，或者說將強關聯改成弱關聯。繼承是強關聯，聚合是弱關聯。對象

l 強關聯：blog

編譯時期已經肯定的，沒法再運行時動態改變的關聯。繼承

l 弱關聯：接口

能夠在運行時動態改變的關聯。get

結構

橋接模式又叫橋樑模式，柄體模式，接口模式。橋接模式由抽象化角色、修正抽象化角色、實現化角色、修正是實現化角色組成。io

l 抽象化角色（Abstraction）：編譯

抽象化給出的定義，保存一個對實現化對象的引用。因此這個角色必須是抽象類。

l 修正抽象化角色（Refined Abstraction）：
擴展抽象化角色，改變和修正父類的抽象化定義。

l 實現化角色（Implementor）：

給出實現化的接口，不給出具體實現。能夠和抽象化角色的接口定義不一樣。

l 具體實現化角色（Concrete Implementor）：

給出實現化角色接口的具體實現。

結構代碼：

抽象化角色：

/**
 * 抽象化角色
 */
@Data
public abstract class Abstraction {
    private Implementor implementor;

    /**
     * 委派給實現化角色
     */
    public void operate(){
        implementor.doSomething();
    }
}

修正抽象化角色：

/**
 * 修正抽象化角色
 */
public class RefinedAbstraction extends Abstraction{

    @Override
    public void operate() {
        System.out.println("refined operate ...");
        getImplementor().doSomething();
    }
}

實現化角色：

/**
 * 實現化角色
 */
public interface Implementor {

    void doSomething();
}

具體實現化角色：

/**
 * 修正實現化角色
 */
public class ConcreteImplementorA implements Implementor{

    @Override
    public void doSomething() {
        System.out.println("concreteImplementorA doSomething ...");
    }
}

具體實現化角色：

/**
 * 修正實現化角色
 */
public class ConcreteImplementorB implements Implementor{

    @Override
    public void doSomething() {
        System.out.println("concreteImplementorB doSomething ...");
    }
}

客戶端：

/**
 * 客戶端
 */
public class Client {
    public static void main(String[] args) {
        Abstraction abstraction = new RefinedAbstraction();

        Implementor implementor1 = new ConcreteImplementorA();
        System.out.println("setter ConcreteImplementorA");
        abstraction.setImplementor(implementor1);
        abstraction.operate();

        Implementor implementor2 = new ConcreteImplementorB();
        System.out.println("setter ConcreteImplementorB");
        abstraction.setImplementor(implementor2);
        abstraction.operate();

    }
}

示例：

如今有飛機制造商：空中巴士（Airbus）、波音（Boeing）、麥道（McDonnell-Douglas）。能夠生產載客飛機（Passenger Plane）、載貨飛機（Cargo Plane）。

這裏抽象化角色就是飛機種類、實現化角色就是飛機制造商。

抽象化角色：

@Data
public abstract class AirPlane {
    abstract public void operate();
    private AirPlaneMaker airPlaneMaker;
}

實現化角色：

@Getter
public abstract class AirPlaneMaker {
    protected String name;
}

修正抽象化角色：

public class Airbus extends AirPlaneMaker{
    public Airbus() {
        name = "空中巴士";
    }
}

修正抽象化角色：

public class Boeing extends AirPlaneMaker {
    public Boeing() {
        name = "波音";
    }
}

具體實現化角色：

public class CargoPlane extends AirPlane {
    @Override
    public void operate() {
        System.out.println(getAirPlaneMaker().getName() + "載貨的飛機");
    }
}

具體實現化角色：

public class PassengerPlane extends AirPlane {
    @Override
    public void operate() {
        System.out.println(getAirPlaneMaker().getName() + "載人的飛機");
    }
}

客戶端：

public class Client {
    public static void main(String[] args) {
        AirPlaneMaker airbus = new Airbus();
        AirPlaneMaker boeing = new Boeing();

        AirPlane passengerPlane = new PassengerPlane();
        passengerPlane.setAirPlaneMaker(airbus);
        passengerPlane.operate();

        passengerPlane.setAirPlaneMaker(boeing);
        passengerPlane.operate();
        System.out.println();

        AirPlane cargoPlane = new CargoPlane();
        cargoPlane.setAirPlaneMaker(airbus);
        cargoPlane.operate();

        cargoPlane.setAirPlaneMaker(boeing);
        cargoPlane.operate();
    }
}