基本介绍：
    1、桥接模式是指：将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变
    2、是一种结构型设计模式
    3、基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象与行为实现分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展
    桥接模式角色说明：

    • Client类：桥接模式的调用者
    • Implement：行为实现类的接口
    • ConcreteImplementA/B：行为的具体实现
    • 抽象类（Abstraction）：维护了Implement，即Implement的实现类ConcreteImplement，二者是聚合关系，Abstraction充当桥接类
    • RefineAbstraction：是Abstraction抽象类的子类

    UML类图：
    image-20210407135702547.png
    下面有这样一个例子，有小米和Vivo两个手机品牌，每个品牌又都有折叠屏和竖直屏两种类型
    代码示例：

    1. /**
    2.  * 手机品牌
    3.  */
    4. public interface Brand {
    6.     /**
    7.      * 开机
    8.      */
    9.     void open();
    11.     /**
    12.      * 关机
    13.      */
    14.     void close();
    16.     /**
    17.      * 打电话
    18.      */
    19.     void call();
    20. }
    22. /**
    23.  * 小米品牌
    24.  */
    25. public class XiaoMi implements Brand{
    26.     @Override
    27.     public void open() {
    28.         System.out.println("小米开机");
    29.     }
    31.     @Override
    32.     public void close() {
    33.         System.out.println("小米关机");
    34.     }
    36.     @Override
    37.     public void call() {
    38.         System.out.println("小米打电话");
    39.     }
    40. }
    42. /**
    43.  * Vivo品牌
    44.  */
    45. public class Vivo implements Brand {
    46.     @Override
    47.     public void open() {
    48.         System.out.println("Vivo开机");
    49.     }
    51.     @Override
    52.     public void close() {
    53.         System.out.println("Vivo关机");
    54.     }
    56.     @Override
    57.     public void call() {
    58.         System.out.println("Vivo打电话");
    59.     }
    60. }
    1. /**
    2.  * 手机抽象类
    3.  */
    4. public abstract class Phone {
    6.     private Brand brand;
    8.     public Phone(Brand brand){
    9.         this.brand = brand;
    10.     }
    12.     protected void open(){
    13.         brand.open();
    14.     }
    16.     protected void close(){
    17.         brand.close();
    18.     }
    20.     protected void call(){
    21.         brand.call();
    22.     }
    23. }
    25. /**
    26.  * 折叠手机，继承抽象类
    27.  */
    28. public class FoldedPhone extends Phone {
    30.     public FoldedPhone(Brand brand) {
    31.         super(brand);
    32.     }
    34.     @Override
    35.     public void open(){
    36.         super.open();
    37.         System.out.println("折叠手机");
    38.     }
    40.     @Override
    41.     protected void close() {
    42.         super.close();
    43.         System.out.println("折叠手机");
    44.     }
    46.     @Override
    47.     protected void call() {
    48.         super.call();
    49.         System.out.println("折叠手机");
    50.     }
    51. }
    53. /**
    54.  * 竖直屏手机
    55.  */
    56. public class UpRightPhone extends Phone {
    57.     public UpRightPhone(Brand brand) {
    58.         super(brand);
    59.     }
    61.     @Override
    62.     protected void open() {
    63.         super.open();
    64.         System.out.println("竖直手机");
    65.     }
    67.     @Override
    68.     protected void close() {
    69.         super.close();
    70.         System.out.println("竖直手机");
    71.     }
    73.     @Override
    74.     protected void call() {
    75.         super.call();
    76.         System.out.println("竖直手机");
    77.     }
    78. }
    1. /**
    2.  * 调用类
    3.  */
    4. public class Client {
    6.     public static void main(String[] args) {
    7.         new FoldedPhone(new XiaoMi()).call();
    8.         new FoldedPhone(new Vivo()).call();
    9.         new UpRightPhone(new XiaoMi()).call();
    10.         new UpRightPhone(new Vivo()).call();
    11.     }
    12. }

    JDBC的Driver接口，如果从桥接模式来看，Driver就是一个接口

    注意事项：
    1、实现了抽象和实现部分的分离，从而极大的提高了系统的灵活性，让抽象部分和实现部分独立开来，这有助于系统进行分层设计，从而产生更好的结构化系统
    2、对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其他的部分由具体业务来完成
    3、桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本
    4、桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计和编程
    5、桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围有一定的局限性，即需要有这样的应用场景

    使用场景：
    1、对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用
    2、常见场景：JDBC驱动系统