设计模式之桥接模式

理想万岁万万岁2023-09-01 22:50

文章目录

一、介绍

桥接模式，属于结构型设计模式 。通过提供抽象与实现之间的桥接结构 ，把抽象化 与实现化解耦，使得二者可以独立变化。

《Head First 设计模式》：

将抽象和实现放在两个不同的类层次中，使它们可以独立地变化。

《图解设计模式》：

将类的功能层次结构和实现层次结构相分离，使二者能够独立地变化，并在两者之间搭建桥梁，实现桥接。

从专业术语对交接模式的解释来看，总是让人似懂非懂，即使懂了，从代码上实现又让人无法捉摸。典型的每个字都认识，连在一起就不懂了。

下面我们先通过一个简单的例子来演示一下桥接的结构是什么样的，然后对其进行改造，最终实现桥接模式。

二、案例

我们假设一部手机有三个重要部件：电池(Battery) 、摄像头(Camera) 、屏幕(Screen)。当我们拍摄一张高清照片时，需要充足的电量、高像素的摄像头、高分辨率的屏幕。

于是我们可以通过下面的代码完成拍照动作：

  • 电池Battery

    java 复制代码 
    public class Battery {
    public Battery() {
        System.out.println("充足电量的电池");
    }
    
    public void electric() {
        System.out.println("电池供电...");
    }
}

  • 摄像头Camera

    java 复制代码 
    public class Camera {
    public Camera() {
        System.out.println("高清像素的摄像头");
    }
    
    public void catchImg() {
        System.out.println("摄像头捕获图像...");
    }
}

  • 屏幕Screen

    java 复制代码 
    public class Screen {
    public Screen() {
        System.out.println("高分辨率的屏幕");
    }
    
    public void show() {
        System.out.println("屏幕显示照片...");
    }
}

  • 手机Phone

    java 复制代码 
    public class Phone {
    private Battery battery;
    private Camera camera;
    private Screen screen;

    public Phone(Battery battery, Camera camera, Screen screen) {
        this.battery = battery;
        this.camera = camera;
        this.screen = screen;
    }

    public void takePic() {
        System.out.println("手机拍照开始...");
        // 电池供电
        battery.electric();
        // 摄像头捕获图像
        camera.catchImg();
        // 屏幕显示照片
        screen.show();
    }
}

  • 演示

    java 复制代码 
    public static void main(String[] args) {
    Battery battery = new Battery();
    Camera camera = new Camera();
    Screen screen = new Screen();

    Phone phone = new Phone(battery, camera, screen);
    phone.takePic();
}

  • 结果输出

从该案例中可以看出，电池、摄像头、屏幕这三个组件是相互独立的，各自干各自的活，通过手机将他们连接起来就可以进行拍照，这时手机就表现为桥梁的角色。通过桥梁，三个组件相互独立。

1. 组件抽象化

在实际现实中，无论是电池、摄像头、还是屏幕，他们都有各自的品牌厂商，因此我们需要将他们抽象化。如电池有南孚和山羊；摄像头有索尼和徕卡；屏幕有三星和京东方。

所有我们需要做出修改：新建电池、摄像头、屏幕的抽象类；再分别按照品牌厂商对这些抽象类进行实现。

  • 电池抽象类Battery ，及其实现类：南孚电池(NanFu) 、山羊电池(Sheep)

    java 复制代码 
    public interface Battery {

    void electric();
}

public class NanFu implements Battery {
    public NanFu() {
        System.out.println("南孚电池实例化");
    }

    @Override
    public void electric() {
        System.out.println("南孚电池正在供电...");
    }
}

public class Sheep implements Battery {
    public Sheep() {
        System.out.println("山羊电池实例化");
    }

    @Override
    public void electric() {
        System.out.println("山羊电池正在供电...");
    }
}

  • 摄像头抽象类Camera ，及其实现类：徕卡摄像头(Laika) 、索尼摄像头(Sony)

    java 复制代码 
    public interface Camera {

    void catchImg();
}

public class Laika implements Camera {
    public Laika() {
        System.out.println("徕卡摄像头实例化");
    }

    @Override
    public void catchImg() {
        System.out.println("徕卡摄像头捕获图像...");
    }
}

public class Sony implements Camera {
    public Sony() {
        System.out.println("索尼摄像头实例化");
    }

    @Override
    public void catchImg() {
        System.out.println("索尼摄像头捕获图像...");
    }
}

  • 屏幕抽象类Screen ，及其实现类：京东方显示屏(JingDongFang) 、三星显示屏(SanXing)

    java 复制代码 
    public interface Screen {

    void show();
}

public class JingDongFang implements Screen {
    public JingDongFang() {
        System.out.println("京东方显示屏实例化");
    }

    @Override
    public void show() {
        System.out.println("京东方显示屏显示照片...");
    }
}

public class SanXing implements Screen {
    public SanXing() {
        System.out.println("三星显示屏实例化");
    }

    @Override
    public void show() {
        System.out.println("三星显示屏显示照片...");
    }
}

这样一来，手机的构造方法的参数就由原来的具体实现类变成了抽象类。

java 复制代码 
public Phone(Battery battery, Camera camera, Screen screen) {
    this.battery = battery;
    this.camera = camera;
    this.screen = screen;
}

该构造方法参数的实际类型由调用方创建的实例为准。

java 复制代码 
public static void main(String[] args) {
    // 使用南孚电池
    Battery battery = new NanFu();
    // 索尼相机
    Camera camera = new Sony();
    // 京东方显示屏
    Screen screen = new JingDongFang();

    Phone phone = new Phone(battery, camera, screen);
    phone.takePic();
}

输出如下

2. 桥梁抽象化

其实不仅电池、摄像头、屏幕有自己的品牌厂商，手机也不例外，如华为、oppo、vivo等，因此我们也需要将手机这个桥梁的角色抽象化。但是如果我们将该桥梁设计成一个接口，由不同的手机品牌实现该接口，那么就可能会导致不同的实现类具有不同参数的构造方法，如此一来，所有品牌手机的功能虽然受到约束(实现类手机接口)，但是他们的组成结构却千差万别。如下所示

java 复制代码 
public interface MyPhone {
    /**
     * 拍照
     */
    void takePic();
    /**
     * 通话
     */
    void call();

    /**
     * 微信聊天
     */
    void wechat();
}

public class Oppo implements MyPhone{

    private ComponentA componentA;
    private ComponentB componentB;

    public Oppo(ComponentA componentA, ComponentB componentB) {
        this.componentA = componentA;
        this.componentB = componentB;
    }

    @Override
    public void takePic() {
        // 照相
    }

    @Override
    public void call() {
        // 打电话
    }

    @Override
    public void wechat() {
        // 聊微信
    }
}

public class Vivo implements MyPhone{

    private ComponentC componentC;
    private ComponentD componentD;

    public Oppo(ComponentC componentC, ComponentD componentD) {
        this.componentC = componentC;
        this.componentD = componentD;
    }

    @Override
    public void takePic() {
        // 照相
    }

    @Override
    public void call() {
        // 打电话
    }

    @Override
    public void wechat() {
        // 聊微信
    }
}

从上面的代码来看，oppo和vivo虽然实现了**手机(MyPhone)**定义的所有功能，但是却乱七八糟的，oppo手机内部组件是ComponentA和ComponentB，vivo手机内部组件却是ComponentC和ComponentD。这样的话手机行业岂不乱套了。

所以我们对桥梁的抽象化不应采用接口，而是抽象类。

使用抽象类有一个好处是，可以使所有子类拥有相同的内部属性，而且对所有子类的构造方法也做出了约束。

如下所示，我们将手机抽象化一个手机接口(Phone)来定义各个功能，再通过一个 抽象子类(AbstractPhone)实现手机接口定义的功能，并规范构造方法，由华为(HuaWei)、**小米(XiaoMi)**两个品牌继承该抽象子类。

java 复制代码 
public interface Phone {
    /**
     * 拍照
     */
    void takePic();
}

public abstract class AbstractPhone implements Phone {
    private Battery battery;
    private Camera camera;
    private Screen screen;

    public AbstractPhone(Battery battery, Camera camera, Screen screen) {
        this.battery = battery;
        this.camera = camera;
        this.screen = screen;
    }

    @Override
    public void takePic() {
        System.out.println("手机拍照开始...");
        // 电池供电
        battery.electric();
        // 摄像头捕获图像
        camera.catchImg();
        // 屏幕显示照片
        screen.show();
    }
}

public class HuaWei extends AbstractPhone {

    public HuaWei(Battery battery, Camera camera, Screen screen) {
        super(battery, camera, screen);
        System.out.println("华为手机实例化");
    }
}

public class XiaoMi extends AbstractPhone {
    public XiaoMi(Battery battery, Camera camera, Screen screen) {
        super(battery, camera, screen);
        System.out.println("小米手机实例化");
    }
}

通过接口(定义功能) 、抽象子类(桥梁)、**实现类(实现功能)**的方式，就是交接设计模式的实现。

下面我们进行代码测试

java 复制代码 
public static void main(String[] args) {
    Battery battery = new NanFu();
    Camera camera = new Sony();
    Screen screen = new JingDongFang();

    // 华为将南孚电池、索尼相机、京东方显示屏桥接起来形成一部手机
    Phone phone = new HuaWei(battery, camera, screen);
    // 使用华为手机拍照
    phone.takePic();
}

以上就是桥接模式的演变过程，希望通过本篇文章的阅读，能使各位朋友对桥接模式有更深入的理解。

纸上得来终觉浅，绝知此事要躬行。

------------------------我是万万岁，我们下期再见------------------------

相关推荐
我就是程序猿6 分钟前
tomcat的配置
java·tomcat
阳光阿盖尔12 分钟前
EasyExcel的基本使用——Java导入Excel数据
java·开发语言·excel
二十雨辰14 分钟前
[苍穹外卖]-12Apache POI入门与实战
java·spring boot·mybatis
程序员皮皮林14 分钟前
开源PDF工具 Apache PDFBox 认识及使用(知识点+案例)
java·pdf·开源·apache
蔚一15 分钟前
Java设计模式—面向对象设计原则(三) -----＞ 依赖倒转原则DIP(完整详解，附有代码+案例)
java·开发语言·设计模式·intellij-idea·依赖倒置原则
liang899920 分钟前
SpringSecurity原理解析（七）：权限校验流程
java·开发语言
搁浅°87929 分钟前
IO文件拷贝
java·开发语言
Python私教33 分钟前
Python国产新 ORM 框架 fastzdp_sqlmodel 快速入门教程
java·数据库·python
Python私教33 分钟前
Python ORM 框架 SQLModel 快速入门教程
android·java·python
码爸36 分钟前
java 执行es中的sql
java·sql·elasticsearch
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04苍穹外卖面试总结05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07Coze扣子平台完整体验和实践（附国内和国际版对比）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10借助 LocatorJS ，快速定位本地代码