结构型设计模式06-桥接模式

最新推荐文章于 2024-08-23 11:07:43 发布

猫十二懿

最新推荐文章于 2024-08-23 11:07:43 发布

阅读量411

点赞数 2

分类专栏：设计模式文章标签：设计模式桥接模式 java

本文链接：https://blog.csdn.net/qq_56098191/article/details/131102900

版权

设计模式专栏收录该内容

33 篇文章 2 订阅

订阅专栏

🧑‍💻作者：猫十二懿

❤️‍🔥账号：CSDN 、掘金、个人博客、Github

🎉公众号：猫十二懿

桥接模式

1、桥接模式模式介绍

桥接模式（Bridge Pattern）是一种结构型模式之一。它 通过将抽象部分和实现部分分离，使它们可以独立地变化，从而实现了解耦合的设计。桥接模式使用组合而不是继承的方式来连接抽象和实现，使得两者可以独立地变化，互不影响。

1.1 桥接模式基本实现

在桥接模式中，抽象部分和实现部分分别定义为两个独立的接口（Abstraction 和 Implementor）。抽象部分维护一个指向实现部分的引用，它自身包含了一些基本操作，而这些操作的具体实现则委托给实现部分。这样，抽象部分可以通过调用实现部分的方法来完成具体的功能。

通过桥接模式，可以将一个系统分为多个独立的维度，并且可以独立地对每个维度进行扩展和修改。它提供了更好的灵活性和可扩展性，同时也符合面向对象设计的原则。

桥接模式的主要参与角色：

Abstraction（抽象部分）：定义抽象部分的接口，维护一个指向实现部分的引用。

/**
 * @author Shier
 * CreateTime 2023/5/17 12:08
 */
public abstract class Abstraction {
    // 聚合 Implementor 
    protected Implementor implementor;

    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void operation();
}

RefinedAbstraction（扩充抽象部分）：对抽象部分进行扩展，增加新的功能。

/**
 * @author Shier
 * CreateTime 2023/5/17 12:09
 * 扩充抽象
 */
public class RefinedAbstraction extends Abstraction {
    @Override
    public void operation() {
        System.out.println("具体的Abstraction执行了");
        implementor.operation();
    }
}

Implementor（实现部分）：定义实现部分的接口，供抽象部分调用。

/**
 * @author Shier
 * CreateTime 2023/5/17 12:05
 * 实现
 */
public abstract class Implementor {
    public abstract void  operation();
}

ConcreteImplementor（具体实现部分）：实现实现部分的接口，具体完成具体的功能。

/**
 * @author Shier
 * CreateTime 2023/5/17 12:06
 * 具体实现A
 */
public class ConcreteImplementorA extends Implementor {
    @Override
    public void operation() {
        System.out.println("具体实现 A 的方法执行了！");
    }
}


/**
 * @author Shier
 * CreateTime 2023/5/17 12:06
 * 具体实现B
 */
public class ConcreteImplementorB extends Implementor {
    @Override
    public void operation() {
        System.out.println("具体实现 B 的方法执行了！");
    }
}

客户端：

/**
 * @author Shier
 * CreateTime 2023/5/17 12:09
 */
public class BridgeClient {
    public static void main(String[] args) {
        Abstraction abstraction= new RefinedAbstraction();
        // 传入A实现类
        abstraction.setImplementor(new ConcreteImplementorA());
        abstraction.operation();

        // 传入B实现类
        abstraction.setImplementor(new ConcreteImplementorB());
        abstraction.operation();
    }
}

结果如下：

桥接模式可以应用于很多场景，特别是当一个系统需要在多个维度上进行扩展和变化时。例如，当一个抽象类有多个子类，而这些子类又有多个实现类时，可以使用桥接模式将抽象类与实现类解耦，使得它们可以独立地变化和扩展。

桥接模式实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。

2、具体案例说明

案例背景：在手机问世之初，存在很多的限制，两个不同品牌手机不能使用同一个应用，也就是存在兼容的问题，很多APP都是各自生产的，只能兼容自家的手机硬件。那么两个品牌手机，都有游戏，我觉得从面向对象的思想来说，应该有一个父类 ‘手机品牌游戏’，然后让N和M品牌的手机游戏都继承于它，这样可以实现同样的运行方法。

同时，由于手机都需要通讯录功能，于是N品牌和M品牌都增加了通讯录的增删改查功能。

2.1 不使用桥接模式实现

会出现紧耦合的问题

先看看代码结构图：

父类应该是 ‘手机品牌’ ，下有 ‘手机品牌M’ 和 ‘手机品牌N’，每个子类下各有 ‘通讯录’ 和 ‘游戏’ 子类。

手机类：

/**
 * @author Shier
 * CreateTime 2023/5/17 16:54
 * 手机品牌
 */
public class PhoneBrand {
    public void run(){}
}

手机品牌N和手机品牌M类：

/**
 * @author Shier
 * CreateTime 2023/5/17 16:55
 * 手机品牌M
 */
public class PhoneBrandM extends PhoneBrand{
}

/**
 * @author Shier
 * CreateTime 2023/5/17 16:55
 * 手机品牌N
 */
public class PhoneBrandN extends PhoneBrand{
}

下属的各自通讯录类和游戏类：

/**
 * @author Shier
 * CreateTime 2023/5/17 16:56
 * 游戏
 */
public class PhoneBrandMGame extends PhoneBrandM {
    public void run(){
        System.out.println("执行M品牌手机游戏");
    }
}

public class PhoneBrandNGame extends PhoneBrandN {
    public void run(){
        System.out.println("执行N品牌手机游戏");
    }
}

/**
 * @author Shier
 * CreateTime 2023/5/17 16:57
 * 通讯录
 */
public class PhoneBrandMAddressList extends PhoneBrandM{
    public void run(){
        System.out.println("运行M品牌手机通讯录");
    }
}

public class PhoneBrandNAddressList extends PhoneBrandN {
    public void run() {
        System.out.println("运行N品牌手机通讯录");
    }
}

客户端代码：

/**
 * @author Shier
 * CreateTime 2023/5/17 16:59
 */
public class PhoneClient {
    public static void main(String[] args) {
        // 调用M手机游戏
        PhoneBrand mGame = new PhoneBrandMGame();
        mGame.run();
        // 调用M手机通讯录
        PhoneBrand  mAddressList= new PhoneBrandMAddressList();
        mAddressList.run();

        // 调用N手机游戏
        PhoneBrand nGame = new PhoneBrandNGame();
        nGame.run();
        // 调用N手机通讯录
        PhoneBrand  nAddressList= new PhoneBrandNAddressList();
        nAddressList.run();

    }
}

功能来说，算是实现了，但是要是再增加一个音乐播放呢？

在每个品牌的下面都增加一个子类。但是这些子类的却别并不是很大。

如果又有了新的手机品牌，它同样有以上的功能，就得再增加这些重复的子类。

我们一直在用面向对象的理论设计的，先有一个品牌，然后多个品牌就抽象出一个品牌抽象类，对于每个功能，就都继承各自的品牌。或者，不从品牌，从手机软件的角度去分类，这有什么问题呢？

是呀，就像我们刚开始学会用面向对象的继承时，感觉它既新颖又功能强大，所以只要可以用，就都用上继承。这就好比是有了新锤子，所有的东西看上去都成了钉子。但事实上，很多情况用继承会带来麻烦。类之间的耦合度很高，修改一个类牵涉到其他的类

比如，对象的继承关系是在编译时就定义好了，所以无法在运行时改变从父类继承的实现。子类的实现与它的父类有非常紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。

这样的继承结构，如果不断地增加新品牌或新功能，类会越来越多的。

这里就要使用到合成 / 聚合复用原则：尽量使用合成／聚合，尽量不要使用类继承。

2.2 使用桥接模式实现

使用的合成 / 聚合复用模式的结构图：

手机品牌包含手机软件，但软件并不是品牌的一部分，所以它们之间是聚合关系。

手机软件抽象类：

/**
 * @author Shier
 * CreateTime 2023/5/17 17:14
 * 手机软件类
 */
public abstract class PhoneSoft {
    // 执行
    public abstract void run();
}

游戏、通讯录等具体类：

/**
 * @author Shier
 * CreateTime 2023/5/17 17:15
 * 手机游戏
 */
public class PhoneGame extends PhoneSoft{
    @Override
    public void run() {
        System.out.println("手机游戏");
    }
}

/**
 * @author Shier
 * CreateTime 2023/5/17 17:16
 * 手机通讯录
 */
public class PhoneAddressList extends PhoneSoft {
    @Override
    public void run() {
        System.out.println("手机通讯录");
    }
}

手机品牌类：

/**
 * @author Shier
 * CreateTime 2023/5/17 17:17
 * 手机品牌
 */
public abstract class PhoneBrand {
    protected PhoneSoft phoneSoft;

    /**
     * 设置手机软件
     *
     * @param phoneSoft
     */
    public void setPhoneSoft(PhoneSoft phoneSoft) {
        this.phoneSoft = phoneSoft;
    }

    /**
     * 执行
     */
    public abstract void run();
}

手机品牌具体类M、N：

/**
 * @author Shier
 * CreateTime 2023/5/17 16:55
 * 手机品牌M
 */
public class PhoneBrandM extends PhoneBrand {
    @Override
    public void run() {
        System.out.print("品牌M");
        phoneSoft.run();
    }
}

/**
 * @author Shier
 * CreateTime 2023/5/17 16:55
 * 手机品牌N
 */
public class PhoneBrandN extends PhoneBrand {
    @Override
    public void run() {
        System.out.print("品牌N");
        phoneSoft.run();
    }
}

客户端代码：

/**
 * @author Shier
 * CreateTime 2023/5/17 16:59
 */
public class PhoneClient {
    public static void main(String[] args) {
        // 调用 M 品牌手机
        PhoneBrand brandM = new PhoneBrandM();
        // 调用通用的手机游戏
        brandM.setPhoneSoft(new PhoneGame());
        brandM.run();
        // 通讯录
        brandM.setPhoneSoft(new PhoneAddressList());
        brandM.run();

        // 调用N品牌手机
        PhoneBrand brandN = new PhoneBrandN();
        // 手机游戏
        brandN.setPhoneSoft(new PhoneGame());
        brandN.run();
        // 通讯录
        brandN.setPhoneSoft(new PhoneAddressList());
        brandN.run();
    }
}

输出结果：

相比之前不使用桥接模式和合成/聚合复用原则时，代码更加清晰了许多，而且如果需要新增一个功能时，比如手机音乐播放功能，那么只要增加这个类就行了。不会影响其他任何类。类的个数增加也只是一个。

/**
 * @author Shier
 * CreateTime 2023/5/17 17:30
 * 手机播放音乐
 */
public class PhoneMusicPlay extends PhoneSoft {
    @Override
    public void run() {
        System.out.println("播放音乐");
    }
}

如果是要增加S品牌，只需要增加一个品牌子类就可以了。个数也是一个，不会影响其他类的改动。

/**
 * @author Shier
 * CreateTime 2023/5/17 17:31
 * 手机品牌S
 */
public class PhoneBrandS extends PhoneBrand {
    @Override
    public void run() {
        System.out.print("手机品牌S");
    }
}