一、从场景中领悟什么是桥接模式

在几何图形的分类中，假设我们有矩形和椭圆之分，这时我们又希望加入颜色（红色、绿色）来拓展它的层级。

用程序来模拟
(1)python语言版

from abc import ABCMeta, abstractmethod


class Shape(metaclass=ABCMeta):
    """形状"""

    def __init__(self, color):
        self._color = color

    def getShapeType(self):
        pass

    def getShapeInfo(self):
        return self._color.getColor() + "的" + self.getShapeType()


class Rectangle(Shape):
    """矩形"""

    def __init__(self, color):
        super().__init__(color)

    def getShapeType(self):
        return "矩形"


class Ellipse(Shape):
    """椭圆"""

    def __init__(self, color):
        super().__init__(color)

    def getShapeType(self):
        return "椭圆"


class Color(metaclass=ABCMeta):
    """颜色"""

    @abstractmethod
    def getColor(self):
        pass


class Red(Color):
    """红色"""

    def getColor(self):
        return "红色"


class Green(Color):
    """绿色"""

    def getColor(self):
        return "绿色"


def testShap():
    redRect = Rectangle(Red())
    print(redRect.getShapeInfo())
    greenRect = Rectangle(Green())
    print(greenRect.getShapeInfo())

    redEllipse = Ellipse(Red())
    print(redEllipse.getShapeInfo())
    greenEllipse = Ellipse(Green())
    print(greenEllipse.getShapeInfo())


if __name__ == "__main__":
    testShap()

（2）go语言版

package main

import "fmt"

type Color interface {
    getColor() string
}

type Red struct {
}

func (r Red) getColor() string {
    return "红色"
}

type Green struct {
}

func (g Green) getColor() string {
    return "绿色"
}

type Shape interface {
    getShapeType() string
    getShapeInfo() string
}

type Rectangle struct {
    color Color
}

func (r Rectangle) getShapeType() string {
    return "矩形"
}

func (r Rectangle) getShapeInfo() string {
    return r.color.getColor() + "的" + r.getShapeType()
}

type Ellipse struct {
    color Color
}

func (e Ellipse) getShapeType() string {
    return "椭圆"
}

func (e Ellipse) getShapeInfo() string {
    return e.color.getColor() + "的" + e.getShapeType()
}

func testShape() {
    readRect := Rectangle{Red{}}
    fmt.Println(readRect.getShapeInfo())
    greenRect := Rectangle{Green{}}
    fmt.Println(greenRect.getShapeInfo())

    readEllipse := Ellipse{Red{}}
    fmt.Println(readEllipse.getShapeInfo())
    greenEllipse := Ellipse{Green{}}
    fmt.Println(greenEllipse.getShapeInfo())
}

func main() {
    testShape()
}

二、什么是桥接模式

将抽象和实现解耦，使得它们可以独立地变化。桥接模式也被称为桥梁模式。桥梁模式是结构型模式，侧重于软件结构。而策略模式关注的是对算法、规则的封装，使得算法可以独立于使用它的用户而变化；策略模式是行为型模式，侧重于对象行为。

三、桥接模式的模型抽象

桥接模式的类图.png

Implementor是一个实现化角色，定义必要的行为和属性；ImplementorImplA和ImplementorImplB是具体的实现化角色。Abstraction是抽象化角色，它的作用是对实现化角色 Implementor 进行一些行为的抽象；RefinedAbstraction 是抽象化角色的具体实现类，对抽象化角色进行修改。

继承关系的类图.png

使用桥接模式的类图.png

四、应用场景

（1）一个产品（或对象）有多种分类和多种组合，即两个（或多个）独立变化的维度，每个维度都希望独立进行扩展。
（2）因为使用继承或因为多层继承导致系统类的个数急剧增加的系统，可以改用桥接模式来实现。

摘录来自
人人都懂设计模式：从生活中领悟设计模式：Python实现