设计模式：Bridge--桥接模式

桥接模式：把事务和具体行为分开，通过bridge桥接调用，实现对接口对应实现的的调用

桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图：

就通过对Bridge类的调用，实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用；

代码：不同的车安装不同的引擎，通过 对引擎结果的引用调用engine，实现了对具体引起的调用，比如2000cc的引擎安装等。

package com.atguigu.bridge.bridgeDemo1;

/**
 * 引擎接口
 */
interface Engine {
    public void installEngine();
}

//2000cc引擎安装
class Engine2000 implements Engine {
    @Override
    public void installEngine() {
        System.out.println("安装2000cc引擎");
    }
}


//2200cc引擎安装
class Engine2200 implements Engine {
    @Override
    public void installEngine() {
        System.out.println("安装2200cc引擎");
    }
}

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


class Bus extends Car {


    public Bus(Engine engine) {
        super(engine);
    }

    @Override
    public void installEngine() {
        System.out.print("Bus：");
        this.getEngine().installEngine();
    }
}

class Jeep extends Car {

    public Jeep(Engine engine) {
        super(engine);
    }

    @Override
    public void installEngine() {
        System.out.print("Jeep：");
        this.getEngine().installEngine();
    }
}

public class MainClass {
    public static void main(String[] args) {
        Engine engine = new Engine2000();

        Car car = new Bus(engine);
        car.installEngine();

        Engine engine1 = new Engine2200();
        Car car1 = new Jeep(engine1);
        car1.installEngine();

    }
}

输出结果：
Bus：安装2000cc引擎
Jeep：安装2200cc引擎

测试结果：

 

二、实例2

/**
 * @auhtor
 * @create 2023-01-10-10:09
 *  画笔
 */
public interface PaintBrush {

    void color();

}

public class Red implements PaintBrush{

    @Override
    public void color() {
        System.out.print("红色画笔");
    }
}

public class Black implements PaintBrush{
    @Override
    public void color() {
        System.out.print("黑色画笔");
    }
}

// 形状抽象类
public abstract class Shape {

    protected PaintBrush paintBrush;

    public Shape(PaintBrush paintBrush) {
        this.paintBrush = paintBrush;
    }

    void draw() {
        paintBrush.color();
    }
}
// 方形
public class Square extends Shape {
    public Square(PaintBrush paintBrush) {
        super(paintBrush);
    }

    @Override
    void draw() {
        super.draw();
        System.out.print("：画方形");
    }
}
// 圆形
public class Circle extends Shape{
    public Circle(PaintBrush paintBrush) {
        super(paintBrush);
    }

    @Override
    void draw() {
        super.draw();
        System.out.print("：画圆形");
    }
}

public class MainClient {
    public static void main(String[] args) {
        PaintBrush red = new Red();
        Shape shape = new Circle(red);
        shape.draw();
    }
}

// console
红色画笔：画圆形

这个图是我们JDBC连接的原理

多个维度扩展就跟jdbc一样可以多次聚合：

比如：如果系统中某对象有三个维度，如某日志记录器既可以支持不同的操作系统，还可以支持多种编程语言，并且可以使用不同的输出方式。请使用桥接模式设计该系统。

 

public abstract class OutPut {

    abstract void outPut(String system, String language);
}


public class ControllerOut extends OutPut{
    @Override
    void outPut(String system, String language) {
        String means="控制台方式输出";
        System.out.println("在"+system+"用"+language+"以"+means);
    }
}

public class FileOut extends OutPut{
    @Override
    void outPut(String system, String language) {
        String means="File方式输出";
        System.out.println("在"+system+"用"+language+"以"+means);
    }
}

public abstract class EncodingLanguage {

    protected OutPut outPut;

    public EncodingLanguage(OutPut outPut) {
        this.outPut = outPut;
    }

    abstract void language(String system);
}


public class C_yuyan extends EncodingLanguage{
    public C_yuyan(OutPut outPut) {
        super(outPut);
    }

    @Override
    void language(String system) {
        String language = "C语言\n";
        outPut.outPut(system, language);
    }
}


public class Java extends EncodingLanguage {
    public Java(OutPut outPut) {
        super(outPut);
    }

    @Override
    void language(String system) {
        String language = "Java语言\n";
        outPut.outPut(system, language);
    }
}

public abstract class OperatingSystem {

    protected EncodingLanguage encodingLanguage;

    public OperatingSystem(EncodingLanguage encodingLanguage) {
        this.encodingLanguage = encodingLanguage;
    }

    abstract void type();
}


public class Linux extends OperatingSystem{
    public Linux(EncodingLanguage encodingLanguage) {
        super(encodingLanguage);
    }

    @Override
    void type() {
        String system="Linux系统";
        encodingLanguage.language(system);
    }
}

public class Windows extends OperatingSystem{
    public Windows(EncodingLanguage encodingLanguage) {
        super(encodingLanguage);
    }

    @Override
    void type() {
        String system="Windows系统";
        encodingLanguage.language(system);
    }
}

public class MainClient {
    public static void main(String[] args) {
        Linux linux = new Linux(new Java(new ControllerOut()));
        linux.type();
    }
}
// console
在Linux系统用Java语言
以控制台方式输出