【设计模式】桥接模式

桥接（Bridge）模式

　　先举个现实生活中的例子，现在对不同手机类型的不同品牌实现操作编程（比如：开机、关机、上网、打电话等），如图：

　　

　　如果用传统方式如何解决呢？

　　

　　我们可以看到，使用传统方式解决手机操作问题会存在下列问题：

1. 扩展性问题（类爆炸），如果我们再增加手机的样式（旋转式），就需要增加各个品牌手机的类，同样如果我们增加一个手机品牌，也要在各个手机样式类下增加

2. 违反了单一职责原则，当我们增加手机样式时，要同时增加所有品牌的手机，这样增加了代码维护成本

3. 解决方案——使用桥接模式

桥接（Bridge）模式——基本介绍

桥接（Bridge）模式是指

1. 将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变

2. 是一种结构型设计模式

3. Bridge 模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象（Abstraction）与行为实现（Implementation）分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展

桥接（Bridge）模式的优点是　　

1. 由于抽象与实现分离，所以扩展能力强

2. 其实现细节对客户透明

缺点是

　　由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，这增加了系统的理解与设计难度

桥接模式的结构与实现

模式的结构

桥接（Bridge）模式包含以下主要角色

1. 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用

2. 扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法

3. 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用

4. 具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现

　　结构图如图 1 所示：

　　

模式的实现

package bridge;
 
public class BridgeTest {
    public static void main(String[] args) {
        Implementor imple=new ConcreteImplementorA();
        Abstraction abs=new RefinedAbstraction(imple);
        abs.Operation();
    }
}
 
// 实现化角色
interface Implementor {
    public void OperationImpl();
}
 
// 具体实现化角色
class ConcreteImplementorA implements Implementor {
    public void OperationImpl() {
        System.out.println("具体实现化(Concrete Implementor)角色被访问" );
    }
}
 
// 抽象化角色
abstract class Abstraction {
   protected Implementor imple;
   protected Abstraction(Implementor imple) {
       this.imple=imple;
   }
   public abstract void Operation();   
}
 
// 扩展抽象化角色
class RefinedAbstraction extends Abstraction {
   protected RefinedAbstraction(Implementor imple) {
       super(imple);
   }
 
   public void Operation() {
       System.out.println("扩展抽象化(Refined Abstraction)角色被访问" );
       imple.OperationImpl();
   }
}

 

　　程序的运行结果如下：

1. 扩展抽象化(Refined Abstraction)角色被访问
2. 具体实现化(Concrete Implementor)角色被访问

桥接模式解决手机操作问题

结构图

　　

代码示例

// 接口
public interface Brand {
    void open(); 
    void close(); 
    void call();
}

 

package com.atguigu.bridge;
 
public class XiaoMi implements Brand {
 
    @Override
    public void open() {
        System.out.println(" 小米手机开机 "); 
    }
 
    @Override
    public void close() {
        System.out.println(" 小米手机关机 "); 
    }
 
    @Override
    public void call() {
        System.out.println(" 小米手机打电话 "); 
    }
}

package com.atguigu.bridge;
 
public class Vivo implements Brand {
 
    @Override
    public void open() {
        System.out.println(" Vivo 手机开机 ");
    }
 
    @Override
    public void close() {
        System.out.println(" Vivo 手机关机 "); 
    }
 
    @Override
    public void call() {
        System.out.println(" Vivo 手机打电话 "); 
    }
}

package com.atguigu.bridge; 
 
public abstract class Phone {
    // 组合品牌
    private Brand brand;
 
    // 构造器
    public Phone(Brand brand) {
        super();
        this.brand = brand; 
    }
 
    protected void open() { 
        this.brand.open();
    }
 
    protected void close() {
        brand.close(); 
    }
 
    protected void call() { 
        brand.call();
    } 
}

package com.atguigu.bridge;
 
// 折叠式手机类，继承抽象类Phone
public class FoldedPhone extends Phone {
    // 构造器
    public FoldedPhone(Brand brand) {
        super(brand); 
    }
 
    public void open() { 
        super.open();
        System.out.println(" 折叠样式手机 "); 
    }
 
    public void close() { 
        super.close();
        System.out.println(" 折叠样式手机 "); 
    }
 
    public void call() { 
        super.call();
        System.out.println(" 折叠样式手机 "); 
    }
}

package com.atguigu.bridge; 
 
public class Client {
    public static void main(String[] args) { 
        // 获取折叠式手机 (样式 + 品牌 )
        Phone phone1 = new FoldedPhone(new XiaoMi());
        phone1.open(); 
        phone1.call(); 
        phone1.close();
        System.out.println("=============="); 
 
        Phone phone2 = new FoldedPhone(new Vivo()); 
        phone2.open();
        phone2.call(); 
        phone2.close();
        System.out.println("==============");
 
        UpRightPhone phone3 = new UpRightPhone(new XiaoMi());
        phone3.open(); 
        phone3.call(); 
        phone3.close();
        System.out.println("==============");
 
        UpRightPhone phone4 = new UpRightPhone(new Vivo());
        phone4.open(); 
        phone4.call(); 
        phone4.close();
    } 
}

桥接模式在 JDBC 的源码剖析

　　Jdbc 的 Driver 接口，如果从桥接模式来看，Driver 就是一个接口，下面可以有 MySQL 的 Driver，Oracle 的 Driver，这些就可以当做实现接口类

　　

　　对 jdbc 源码分析的类图

　　

桥接模式的注意事项和细节

1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，这有助于系统进行分层设计，从而产生更好的结构化系统

2. 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成

3. 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本

4. 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计和编程

5. 桥接模式要求正确识别出系统中两个独立变化的维度(抽象、和实现)，因此其使用范围有一定的局限性，即需要有这样的应用场景

桥接模式的应用场景

　　桥接模式通常适用于以下场景

1. 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时

2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时

3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时

　　常见的应用场景　　

1. JDBC驱动程序

2. 银行转账系统——转账分类: 网上转账，柜台转账，AMT 转账；转账用户类型:普通用户，银卡用户，金卡用户..

3. 消息管理——消息类型:即时消息，延时消息；消息分类：手机短信，邮件消息，QQ 消息...

 桥接模式模式的扩展

　　在软件开发中，有时桥接（Bridge）模式可与适配器模式联合使用。当桥接（Bridge）模式的实现化角色的接口与现有类的接口不一致时，可以在二者中间定义一个适配器将二者连接起来，其具体结构图如图 5 所示

　　

 

原文链接：https://blog.csdn.net/qq784515681/article/details/106087730