结构型模式概述

定义：前篇初期中，我们的讲过结构型模式主要解决的问题是：

• 处理实体之间的关系，使得这些实体能够更好地协同工作
• 结构型模式是类和对象的综合体

它具有的特性：

• 1：设计过程注重通过组合获得更强大功能的对象和类的结构
• 2：简化结构并识别类和对象之间的关系
• 3：主要关注类的继承和组合
• 4：通过类和对象的模式的

桥接模式

所属分类

• 结构型模式

意图

• 将代码的抽象部分与实现部分相分离，使二者都可以独立地变化
• 桥接，是指抽象部分和实体部分的连接，简单来说是类和类实例化过称中的连接。

核心的思想

如何通过桥接类的封装来把我们需要桥接的实现部分链接到抽象的部分上面。

适用性

• 不希望在抽象和它的实现部分之间有一个固定的绑定关系。

现实指导意义：

• 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。
• 可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充
• 把系统各维度抽象出来，各维度独立变化
• 各维度可通过聚合进行组合，减少了各维度间的耦合

实践

from abc import ABCMeta,abstractmethod

class Phone(metaclass=ABCMeta):

    @abstractmethod
    def make(self, name):pass

class Apple(Phone):

    def make(self, name):
        print("由{}-代工生产苹果手机".format(name))

class XiaoMi(Phone):
    def make(self, name):
        print("由{}-代工生产小米手机".format(name))


class Bridge:

    def __init__(self,obj_class,name):
        self.name = name
        self.obj_class = obj_class

    def bridge_make(self):
        self.obj_class.make(self.name)


if __name__ == '__main__':
    test = Bridge(Apple(),'富士康')
    test.bridge_make()
    test = Bridge(XiaoMi(),'小米自加工')
    test.bridge_make()

输出结果：

由富士康-代工生产苹果手机
由小米自加工-代工生产小米手机

上面代码中：

• 将代码的抽象部分（是指我们的单独的具体产品对象的生成方法）
• 而实现则是听过桥接类中-- test = Bridge(Apple(),'富士康')--进行具体产品实例化，且附加对应的属性，来组合调用原来的抽象部分的方法

所以：桥接，是指抽象部分和实体部分（Apple(),'富士康'）的连接，简单来说是类和类实例化过称中的连接。

另一种理解示例：

涉及角色对象：

上面的示例的角色划分：

• 抽象：肉(需要加工完成才能吃)
• 实现者：对肉的加工做法是一种实现
• 细化抽象：各种各样的肉：猪肉，牛肉，牛蛙肉，排骨···
• 具体实现着：红烧，炭烧，水煮····

示例

from abc import ABCMeta, abstractmethod


class Zhufa(metaclass=ABCMeta):

   # 定义煮肉的方法
   @abstractmethod
   def make_fun(self, rou): pass


# 水煮做法
class ShuizhuZhufa(Zhufa):
   def make_fun(self, rou):
       print("水煮的", rou.name)
       return self


# 红烧做法
class HongshaoZhufa(Zhufa):
   def make_fun(self, rou):
       print("红烧的", rou.name)
       return self


# 炭烧做法
class TanshaoZhufa(Zhufa):
   def make_fun(self, rou):
       print("炭烧的", rou.name)
       return self


# ======================
class Rou(metaclass=ABCMeta):

   def __init__(self, zhufa):
       # 烹饪的方式
       self.zhufa = zhufa

   @abstractmethod
   def make(self): pass

# ======================
# 具体的类桥接 肉和做法的类
class Niurou(Rou):
   name = "牛肉"

   def make(self):
       return self.zhufa.make_fun(self)


class Zhurou(Rou):
   name = "猪肉"

   def make(self):
       return self.zhufa.make_fun(self)


class Yangrou(Rou):
   name = "羊肉"

   def make(self):
       return self.zhufa.make_fun(self)


class Niuwa(Rou):
   name = "牛蛙肉"

   def make(self):
       return self.zhufa.make_fun(self)

if __name__ == '__main__':
   print('*'*20)
   Niurou(ShuizhuZhufa()).make()
   Niurou(HongshaoZhufa()).make()
   Niurou(TanshaoZhufa()).make()
   print('*'*20)
   Yangrou(ShuizhuZhufa()).make()
   Yangrou(HongshaoZhufa()).make()
   Yangrou(TanshaoZhufa()).make()
   print('*' * 20)
   Niuwa(TanshaoZhufa()).make()
   Niuwa(HongshaoZhufa()).make()
   Niuwa(ShuizhuZhufa()).make()
   print('*' * 20)

输出结果：

********************
水煮的 牛肉
红烧的 牛肉
炭烧的 牛肉
********************
水煮的 羊肉
红烧的 羊肉
炭烧的 羊肉
********************
炭烧的 牛蛙肉
红烧的 牛蛙肉
水煮的 牛蛙肉
********************

分析：

1：首先有肉和肉的做法两个抽象类

2：在肉的抽象类里面class Rou(metaclass=ABCMeta),依赖于我们的做法class Zhufa(metaclass=ABCMeta)的具体对象。

3：在做法的抽象类里面class Zhufa(metaclass=ABCMeta)的方法里面依赖我们的需要制作的肉的实例def make_fun(self, rou): pass

3：定义各式各样的肉的做法具体实现类（实现了肉的做法的抽象类）

4：再次各式各样的肉的具体实现类（实现了肉的抽象类）

上面的这种方式不是一种紧耦合的方式，是通过一个组合的方式来实现松藕合，后续如果新增其他的肉类的话，只需要新建一个新的肉的实现就可以把两个不同维度的类的扩展。

class Turou(Rou):
    name = "兔肉"

    def make(self):
        return self.zhufa.make_fun(self)

if __name__ == '__main__':
    print('*' * 20)
    Turou(TanshaoZhufa()).make()
    Turou(HongshaoZhufa()).make()
    Turou(ShuizhuZhufa()).make()

输出的结果为：

********************
炭烧的 兔肉
红烧的 兔肉
水煮的 兔肉

上面的 做法和 肉 的新增各自都是独立的，互不影响。

个人其他博客地址

简书：https://www.jianshu.com/u/d6960089b087

掘金：https://juejin.cn/user/2963939079225608

小钟同学 | 文 【原创】| QQ：308711822

• 1：本文相关描述主要是个人的认知和见解，如有不当之处，还望各位大佬指正。
• 2：关于文章内容，有部分内容参考自互联网，如有链接会声明标注；如没有及时标注备注的链接的，如有侵权请联系，我会立即删除处理哟。