桥接模式

桥接模式是软件设计模式中最复杂的模式之一，它把事物对象和其具体行为、具体特征分离开来，使它们可以各自独立的变化。
概述.
事物对象仅是一个抽象的概念，如“圆形”、“三角形”归于抽象的“形状”之下，而“画圆”、“画三角”归于实现行为的“画图”类之下，然后将事物对象与其行为桥接起来，即由“形状”调用“画图”，例如：“圆形”调用“画圆”，而“三角形”调用“画三角”。
结构.
在上面的UML类图中，抽象类（codice_1）不实现为平常的单一继承层级。这里转而有个层级用于抽象类（codice_1），另一个独立的层级用于它的实现（codice_3），这使得二者相互独立。codice_1接口（codice_5）的实现依据了（委托于）codice_3接口（codice_7）。
UML序列图展示了运行时交互：codice_8对象委托实现于codice_9对象（通过调用codice_10在codice_9之上），它进行运算并返回到codice_8。
示例.
下列各语言的代码都用于写出两个不同的圆的坐标和半径。
C++.
下面是C++的例子：
using namespace std;
/* Implementor*/
class DrawingAPI {
public:
 virtual void drawCircle(double x, double y, double radius) = 0;
/* Concrete ImplementorA*/
class DrawingAPI1 : public DrawingAPI {
public:
 void drawCircle(double x, double y, double radius) {
 cout « "API1.circle at " « x « ':' « y « ' ' « radius « endl;
};
/* Concrete ImplementorB*/
class DrawingAPI2 : public DrawingAPI {
public:
 void drawCircle(double x, double y, double radius) {
 cout « "API2.circle at " « x « ':' « y « ' ' « radius « endl;
};
/* Abstraction*/
class Shape {
public:
 virtual void draw() = 0;
 virtual void resizeByPercentage(double pct) = 0;
/* Refined Abstraction*/
class CircleShape : public Shape {
public:
 CircleShape(double x, double y,double radius, DrawingAPI *drawingAPI) :
 void draw() {
 m_drawingAPI-&gt;drawCircle(m_x, m_y, m_radius);
 void resizeByPercentage(double pct) {
 m_radius *= pct;
private:
 double m_x, m_y, m_radius;
 DrawingAPI *m_drawingAPI;
int main(void)
 DrawingAPI1 dap1;
 DrawingAPI2 dap2;
 CircleShape circle1(1,2,3,&amp;dap1);
 CircleShape circle2(5,7,11,&amp;dap2);
 circle1.resizeByPercentage(2.5);
 circle2.resizeByPercentage(2.5);
 circle1.draw();
 circle2.draw();
 return 0;
Java.
下面是Java的例子：
/** "Implementor" */
interface DrawingAPI {
 public void drawCircle(double x, double y, double radius);
/** "ConcreteImplementor" 1/2 */
class DrawingAPI1 implements DrawingAPI {
 public void drawCircle(double x, double y, double radius) {
 System.out.printf("API1.circle at %f:%f radius %f\n", x, y, radius);
/** "ConcreteImplementor" 2/2 */
class DrawingAPI2 implements DrawingAPI {
 public void drawCircle(double x, double y, double radius) { 
 System.out.printf("API2.circle at %f:%f radius %f\n", x, y, radius);
/** "Abstraction" */
interface Shape {
 public void draw(); // low-level
 public void resizeByPercentage(double pct); // high-level
/** "Refined Abstraction" */
class CircleShape implements Shape {
 private double x, y, radius;
 private DrawingAPI drawingAPI;
 public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI) {
 this.x = x; this.y = y; this.radius = radius; 
 this.drawingAPI = drawingAPI;
 // low-level i.e. Implementation specific
 public void draw() {
 drawingAPI.drawCircle(x, y, radius);
 // high-level i.e. Abstraction specific
 public void resizeByPercentage(double pct) {
 radius *= pct;
/** "Client" */
class BridgePattern {
 public static void main(String[] args) {
 Shape[] shapes = new Shape[2];
 shapes[0] = new CircleShape(1, 2, 3, new DrawingAPI1());
 shapes[1] = new CircleShape(5, 7, 11, new DrawingAPI2());
 for (Shape shape : shapes) {
 shape.resizeByPercentage(2.5);
 shape.draw();
C#.
在下面的C#例子中，泛型形式的codice_13，通过codice_14来接受接口codice_15的codice_16形式的继承者。
using System;
/** "Implementor" */
interface IDrawingAPI {
 void DrawCircle(double x, double y, double radius);
 
/** "ConcreteImplementor" 1/2 */
struct DrawingAPI1 : IDrawingAPI {
 public void DrawCircle(double x, double y, double radius) {
 System.Console.WriteLine("API1.circle at {0}:{1} radius {2}", x, y, radius); 
/** "ConcreteImplementor" 2/2 */
struct DrawingAPI2 : IDrawingAPI {
 public void DrawCircle(double x, double y, double radius) { 
 System.Console.WriteLine("API2.circle at {0}:{1} radius {2}", x, y, radius); 
 /** "Abstraction" */
interface IShape {
 void Draw(); // low-level (i.e. Implementation-specific)
 void ResizeByPercentage(double pct); // high-level (i.e. Abstraction-specific)
 
/** "Refined Abstraction" */
class CircleShape&lt;T&gt; : IShape
 where T : struct, IDrawingAPI {
 private double x, y, radius;
 private static IDrawingAPI drawingAPI = new T();
 public CircleShape(double x, double y, double radius) {
 this.x = x; this.y = y; this.radius = radius;
 // low-level (i.e. Implementation-specific)
 // high-level (i.e. Abstraction-specific)
 
/** "Client" */
class BridgePattern {
 public static void Main(string[] args) {
 IShape[] shapes = new IShape[2];
 shapes[0] = new CircleShape&lt;DrawingAPI1&gt;(1, 2, 3);
 shapes[1] = new CircleShape&lt;DrawingAPI2&gt;(5, 7, 11);
 foreach (IShape shape in shapes) {
 shape.ResizeByPercentage(2.5);
 shape.Draw();
Python.
Python的例子：
from abc import ABCMeta, abstractmethod
class DrawingINTF(metaclass=ABCMeta):
 @staticmethod
 @abstractmethod
 def draw_impl(): pass
class DrawingCircle1(DrawingINTF):
 @staticmethod
 def draw_impl(x, y, radius):
 print("Implementor1: drawing circle at "
 + f"({x},{y}) and radius={radius}")
class DrawingCircle2(DrawingINTF):
 @staticmethod
 def draw_impl(x, y, radius):
 print("Implementor2: drawing circle at "
 + f"({x},{y}) and radius={radius}")
class Shape(metaclass=ABCMeta):
 def __init__(self, drawing_intf):
 self.drawing_intf = drawing_intf
 @abstractmethod
 def draw(self): pass
 @abstractmethod
 def resize_by_percentage(self): pass
class Circle(Shape):
 def __call__(self, x, y, radius):
 self.x = x
 self.y = y
 self.radius = radius
 return self
 def draw(self):
 self.drawing_intf.draw_impl(
 self.x, self.y, self.radius)
 def resize_by_percentage(self, percent):
 self.radius *= 1 + percent/100
def test():
 shapes = [
 Circle(DrawingCircle1)(1.0, 2.0, 3.0),
 Circle(DrawingCircle2)(5.0, 7.0, 11.0)]
 for shape in shapes:
 shape.resize_by_percentage(2.5)
 shape.draw()
其执行：
»&gt; test()
Implementor1: drawing circle at (1.0,2.0) and radius=3.0749999999999997
Implementor2: drawing circle at (5.0,7.0) and radius=11.274999999999999