桥梁模式在Java应用中一个非常典型的例子就是JDBC驱动器。JDBC为所有的关系型数据库提供一个通用的界面。一个应用系统动态的选择一个合适的驱动器，然后通过驱动器向数据库引擎发出指令。这个过程就是将抽象角色的行为委派给实现角色的过程。

抽象角色可以针对任何数据库引擎发出查询指令，因为抽象角色并不直接�与数据库引擎打交道，JDBC驱动器负责这个底层的工作。由于JDBC驱动器的存在，应用系统可以不依赖于数据库引擎的细节而独立的演化；同时数据库引擎也可以独立�于应用系统的细节而独立的演化。两个独立的等级结构图如下图所示，左边是JDBC API的等级结构，右边是JDBC驱动器的等级结构，应用程序是建立在JDBC API的基础之上的。

JDBC等级结构图

应用系统作为一个等级结构，与JDBC驱动器这个等级结构是相对独立的，它们之间没有静态的强关联。应用系统通过委派与JDBC驱动器相互作用，这是一个桥梁模式的例子。

JDBC这种架构，把抽象部分和具体实现部分分离开来，从而使得抽象部分和具体实现部分都可以独立的扩展。对于应用程序而言，之遥选用不同的驱动，就可以让程序操作不同的数据库，而无需更改应用程序，从而实现在不同的数据库上移植；对于驱动程序而言，为数据库实现不同的驱动程序，并不会影响应用程序。

# 接口实现类

class Implementor:

    def Operation(self):

        raise NotImplementedError

class ConcreteImplementorA(Implementor):

    def Operation(self):

        print("实现 A的方法")

class ConcreteImplementorB(Implementor):

    def Operation(self):

        print("实现 B的方法")

# 抽象类

class Abstraction():

    def __init__(self,implementor):

        self.implementor = implementor

    def Operation(self):

        raise NotImplementedError

class RefineAbstraction(Abstraction):

    def Operation(self):

        self.implementor.Operation()

if __name__ == "__main__":

    a = ConcreteImplementorA()

    b = ConcreteImplementorB()

    aa = RefineAbstraction(a)

    ab = RefineAbstraction(b)

    aa.Operation()

    ab.Operation()

#抽象类:人

class people:

    def set_skill(self,skill):

        self.skill=skill

    def perform_skill(self):

        pass

#具体抽象类:花匠

class hua_j(people):

    def perform_skill(self):

        print('我是花匠')

        self.skill.perform_skill()

#具体抽象类:木匠

class mu_j(people):

    def perform_skill(self):

        print('我是木匠')

        self.skill.perform_skill()

#具体抽象类:铁匠

class tie_j(people):

    def perform_skill(self):

        print('我是铁匠')

        self.skill.perform_skill()

#功能类，也是实现类

class  skill:

    def perform_skill(self):

        pass

#具体功能类，也是具体实现类 种花

class  skill_hua(skill):

    def perform_skill(self):

        print('我会种花')

#具体功能类，也是具体实现类 做木桌子

class  skill_mu:

    def perform_skill(self):

        print('我会做木桌子')

#具体功能类，也是具体实现类 做铁桌子

class  skill_tie:

    def perform_skill(self):

        print('我会做铁桌子')

#具体功能类，也是具体实现类 做老师

class  skill_teacher:

    def perform_skill(self):

        print('我会做老师，可以教学生')

#具体功能类，也是具体实现类 做家具

class  skill_jj:

    def perform_skill(self):

        print('我会做家具')

def main():

    h=hua_j() #花匠

    m=mu_j() #木匠

    t=tie_j() #铁匠

    sh=skill_hua()# 本事:会种花

    sm=skill_mu() #本事:会做木头桌子

    st=skill_tie() #本事:会做铁桌子

    s_t=skill_teacher() #本事:会教学生

    s_jj=skill_jj() #本事:会做家具

    h.set_skill(sh) #给花匠set种花的本事

    h.perform_skill() #花匠 种花

    h.set_skill(s_t) #给花匠set做老师的本事

    h.perform_skill() #花匠教学生

    print('=============')

    m.set_skill(sm) #给木匠set 做木桌子的本事

    m.perform_skill() #木匠 做木桌子

    m.set_skill(s_t) #给木匠set做老师的本事

    m.perform_skill() #木匠教学生

    m.set_skill(s_jj) #给木匠set做家具的本事

    m.perform_skill() #木匠做家具

    print('=============')

    t.set_skill(st) #给木匠set 做木桌子的本事

    t.perform_skill() #木匠 做木桌子

    t.set_skill(s_t) #给木匠set做老师的本事

    t.perform_skill() #木匠教学生

    t.set_skill(s_jj) #给木匠set做家具的本事

    t.perform_skill() #木匠做家具

if __name__ == '__main__':

    main()