Java设计模式之桥梁模式

桥梁模式(Bridge pattern): 使用桥梁模式通过将实现和抽象放在两个不同的类层次中而使它们可以独立改变。

桥梁模式的详解
类图：

可以看出，结构含有两个等级结构：

• 实现化角色和两个具体实现化角色组成的实现化等级结构。
• 抽象化角色和清晰抽象化角色组成的抽象化等级结构。

角色说明：
抽象化角色（Abstraction）：抽象化给出的定义，并保存一个对实现划对象的引用。

清晰抽象化角色（RefinedAbstraction）：扩展抽象化角色，改正和清晰父类对抽象化的定义。

实现化角色（Implementor）：这个角色给出实现化角色的接口，但不给出具体的实现。必须指出的是，这个接口不一定和抽象化角色的接口定义相同，实际上这两个接口可以非常一样。实现化角色应当只给出底层操作，而抽象化角色应当只给出基于底层操作的更高一层的操作。

具体实现化角色（ConcreteImplementor）：它给出实现化角色接口的具体实现。

代码演示，抽象化类：

public abstract class Abstraction {

    protected Implementor impl;

    public Abstraction(Implementor impl) {
        this.impl = impl;
    }

    // 操作方法
    public void operation() {

        impl.operationImpl();
    }
}

清晰抽象化类：

public class RefinedAbstraction extends Abstraction {

    public RefinedAbstraction(Implementor impl) {
        super(impl);
    }

    // 其他的操作方法
    public void otherOperation() {

    }
}

实现化类：

public abstract class Implementor {

     // 操作方法，实现抽象部分需要某些具体的操作 
    public abstract void operationImpl();
}

具体实现化类A：

public class ConcreteImplementorA extends Implementor {

    @Override
    public void operationImpl() {
        // 业务逻辑代码
    }

}

具体实现化类B：

public class ConcreteImplementorB extends Implementor {

    @Override
    public void operationImpl() {
        // 业务逻辑代码
    }

}

接下来运用一个形象的例子来解释说明

先来个问题，最近几年，国产的私家车已经非常的热销了。长城的高端品牌WEI也是。从型号上看，WEI有vv5、vv7两种车型，不同的车型可能业务功能处理是不一样的。从版本上看，又有标准版、高配版和尊贵版等。

结合桥梁模式实现

根据业务需求，业务变化有两个维度，一个是抽象的车型，现在就只包括vv5、vv7；另一个维度是版本，现在就只有标准版、高配版和尊贵版三种

桥梁模式就是让我们要把抽象部分和实现部分这两个维度相互独立分开，这样就可以单独的实现他们，使其扩展变得简单。

类图：

代码演示，抽象型号类：

// 抽象型号类
public class AbstractCarModel {
    // 持有一个实现部分的对象
    CarTypeImplementor impl;

    // 构造时传入实现部分的对象
    public AbstractCarModel(CarTypeImplementor impl) {
        this.impl = impl;
    }

    /**
     * 购买时，委派给实现部分的方法
     * @param manner    购买方式
     * @param price 购买价格
     */
    public void purchaseType(String manner, int price) {
        this.impl.purchase(manner, price);
    }
}

清晰的抽象型号vv5车型类：

//vv5车型类
public class VV5CarModel extends AbstractCarModel {

    public VV5CarModel(CarTypeImplementor impl) {
        super(impl);
    }

    /**
     * 在购买方式后添加购买的车型
     */
    @Override
    public void purchaseType(String manner, int price) {
        manner +="VV5";
        super.purchaseType(manner, price);
    }


}

清晰的抽象型号vv7车型类：

//vv7车型类
public class VV7CarModel extends AbstractCarModel {

    public VV7CarModel(CarTypeImplementor impl) {
        super(impl);

    }

    /**
     * 在购买方式后添加购买的车型
     */
    @Override
    public void purchaseType(String manner, int price) {
        manner +="VV7";
        super.purchaseType(manner, price);
    }
}

实现化类：

//实现版本购买的统一接口
public interface CarTypeImplementor {
    //购买方法
    public void purchase(String manner, int price);
}


具体实现化标准版本类：
//标准版本类
public class CarTypeStandard implements CarTypeImplementor {

    @Override
    public void purchase(String manner, int price) {
        System.out.println(manner+"标准版，花费："+price);

    }

}

具体实现化高配版本类：

//高配版本类
public class CarTypeHighConfig implements CarTypeImplementor {

    @Override
    public void purchase(String manner, int price) {
        System.out.println(manner+"高配版，花费："+price);

    }

}

具体实现化尊贵版本类：

//尊贵版本类
public class CarTypeDignity implements CarTypeImplementor {

    @Override
    public void purchase(String manner, int price) {
        System.out.println(manner+"尊贵版，花费："+price);

    }

}

客户端测试类：

public class Test {

    public static void main(String[] args) {
        // 实例化高配版的对象
        CarTypeImplementor impl = new CarTypeHighConfig();
        // 实例化vv7型号对象
        AbstractCarModel car = new VV7CarModel(impl);
        car.purchaseType("购买", 200000);

        // 再实例化一个标准版的对象
        impl = new CarTypeStandard();
        // 实例化vv5型号对象
        AbstractCarModel car1 = new VV5CarModel(impl);
        car1.purchaseType("赠送", 150000);

    }

}

运行结果：

桥梁模式的优点：

• 桥梁模式分离了抽象部分和实现部分，从而极大地提供了系统的灵活性。让抽象部分和实现部分独立开来，分别定义接口，这有助于对系统分层，从而产生更好的结构化系统。
• 因为桥梁模式把抽象部分和实现部分分离开了，这时它们可以相互独立扩展而不会相互影响，这也大大提供了系统的可扩展性。