桥接模式

桥接模式

       桥接模式的用意是“将抽象化和实现化解耦，使两者能够独立变化”。

 

抽象化：

       存在于多个实体中的共同的概念性联系就是抽象化。抽象化把不一样的实体当作一样的实体对待。

 

实现化：

       抽象化给出的具体实现就是实现化。类的实例是类的实现化，子类是抽象超类的实现化。

 

解耦：

       耦合就是两个实体的行为存在强关联。去掉强关联就是解耦，或者说将强关联改成弱关联。继承是强关联，聚合是弱关联。

l  强关联：

       编译时期已经肯定的，没法再运行时动态改变的关联。

l  弱关联：

能够在运行时动态改变的关联。

 

结构

       桥接模式又叫桥梁模式，柄体模式，接口模式。桥接模式由抽象化角色、修正抽象化角色、实现化角色、修正是实现化角色组成。

 

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();
    }
}

 

输出： 

空中巴士载人的飞机

波音载人的飞机

 

空中巴士载货的飞机

波音载货的飞机

 

小结：

       桥接模式使抽象化与实例化解耦。抽象化角色持有实现化角色的引用，经过传入不一样的实现化角色从而表现出不一样的行为。当有多个修正抽象化角色和多个具体实现化角色时，能够经过组合不一样的修正抽象化角色和具体实现化角色表现出不一样的行为。