桥接模式

定义

将抽象部分与实现（行为）部分分离，使他们都可以独立的变化。
桥接模式的做法是把变化部分（实现）抽象出来，是变化部分与主类（抽象）分离开来，
从而将多个维度的变化彻底分离。最后，提供一个管理类来组合不同维度上的变化，通过这种组合来满足业务的需要。

具体案例

本案例是实现汽车安装引擎的功能
汽车有两种奔驰和宝马他们安装的引擎不同怎么实现?

有两种方法

1.传统方法

public interface Car{
    public void installEngine200();

    public void installEngine300();
}

public class Benz implements Car{
    @Override
    public void installEngine200(){
        System.out.println("Benz车组装Engine200");
    }
    @Override
    public void installEngine300(){
        System.out.println("Benz车组装Engine300");
    }
}

public class Bwm implements Car{
    @Override
    public void installEngine200(){
        System.out.println("Bwm车组装Engine200");
    }
    @Override
    public void installEngine300(){
        System.out.println("Benz车组装Engine300");
    }
}

public class Client {


    public static void main(String[] args) {
        //奔驰车安装200引擎
        Car benz=new Benz();
        benz.installEngine200();
        //宝马车安装300引擎
        Car bwm=new Bwm();
        bwm.installEngine300();
    }
}

缺点：只要在Car接口中增加一个引擎类型的方法，那么它的具体实现类中也得增加一个空实现(如果该车不需要这个引擎)，比如再增加一个型号400的引擎
相应的奔驰和宝马中都得增加该方法但是我奔驰车不需要这种引擎这样造成了代码的冗余所以这种方法不好扩展，这就要用第二种方法：桥接模式

2.使用桥接模式

//Implementor : Engine 定义实现接口(也就是引擎接口)。
//与实现(行为)部分

public interface Engine {
    public void addEngine();
}

//ConcreteImplementor : Engine200 ;Engine300 实现引擎接口中方法。
//具体实现接口

public class Engine200 implements Engine {
    @Override
    public void addEngine() {
        System.out.println("组装Engine200");
    }
}

public class Engine300 implements Engine {
    @Override
    public void addEngine() {
        System.out.println("组装Engine300");
    }
}

//Abstraction : Car 定义抽象接口。
//抽象部分

public abstract class Car {
    private Engine engine;// 持有一个实现部分对象，形成聚合关系

    public Car(Engine engine) {
        this.engine = engine;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public abstract void install();
}

//RefinedAbstraction :Benz ;Bwm 扩展 Abstraction 类。

public class Benz extends Car {
    public Benz(Engine engine) {
        super(engine);
    }
    @Override
    public void install() {
        System.out.println("Benz车安装");
        this.getEngine().addEngine();
    }
}

public class Bwm extends Car {
    public Bwm(Engine engine) {
        super(engine);
    }
    @Override
    public void install() {
        System.out.println("Bwm车安装");
        this.getEngine().addEngine();
    }
}

//测试代码

    public static void main(String[] args) {
        //创建实现(行为)  ->Engine引擎
        //第一种 引擎  
        Engine engine200=new Engine200();
        //第二种 引擎
        Engine engine300=new Engine300();
        //创建抽象    ->车
        Car benz=new Benz(engine200);
        benz.install();
        
        Car bwm=new Bwm(engine300);
        bwm.install();
    }
}

运行结果:

Benz车安装
组装Engine200
Bwm车安装
组装Engine300

应用场景

1.如果不希望在抽象和实现部分采用固定的绑定关系，可以采用桥接模式，来把抽象和实现部分分开，然后在程序运行期间来动态的设置抽象部分需要用到的具体实现，还可以动态切换具体的实现。

2.如果出现抽象部分和实现部分都应该可以扩展的情况，可以采用桥接模式，让抽象部分和实现部分可以独立的变化，从而可以灵活的进行单独扩展，而不是搅在一起，扩展一边回影响另一边。

3.如果希望实现部分的修改，不会对客户产生影响，可以采用桥接模式，客户是面向对象的接口在运行，实现部分的修改

3、如果希望实现部分的修改，不会对客户产生影响，可以采用桥接模式，客户是面向抽象的接口在运行，实现部分的修改，可以独立于抽象部分，也就不会对客户产生影响了，也可以说对客户是透明的。

4、如果采用继承的实现方案，会导致产生很多子类，对于这种情况，可以考虑采用桥接模式，分析功能变化的原因，看看是否能分离成不同的纬度，然后通过桥接模式来分离它们，从而减少子类的数目。

设计模式——桥接模式