**橋接模式**是軟件設計模式中最複雜的模式之一，它把事物對象和其具體行爲、具體特徵分離開來，使它们可以各自独立的变化。事物對象僅是一個抽象的概念。如"圓形"、"三角形"歸于抽象的"形狀"之下，而"畫圓"、"畫三角"歸于實現行爲的"畫圖"類之下，然後由"形狀"調用"畫圖"。

結構
--

Abstraction
定義抽象的介面
該介面包含實現具體行爲、具體特徵的Implementor介面
Refined Abstraction
抽象介面Abstraction的子類，依舊是一個抽象的事物名
Implementor
定義具體行爲、具體特徵的應用介面
ConcreteImplementor
實現Implementor介面

示例
--

下列各語言的代碼都用於寫出兩個不同的圓的坐標和半徑。

```
API1.circle at 1:2 7.5
API2.circle at 5:7 27.5

```

### 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#

  

```
 using System;
 
 /\*\* "Implementor" \*/
 interface IDrawingAPI {
 void DrawCircle(double x, double y, double radius);
 }
 
 /\*\* "ConcreteImplementor" 1/2 \*/
 class 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 \*/
 class 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 : IShape {
 private double x, y, radius;
 private IDrawingAPI drawingAPI;
 public CircleShape(double x, double y, double radius, IDrawingAPI 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) {
 IShape[] shapes = new IShape[2];
 shapes[0] = new CircleShape(1, 2, 3, new DrawingAPI1());
 shapes[1] = new CircleShape(5, 7, 11, new DrawingAPI2());
 
 foreach (IShape shape in shapes) {
 shape.ResizeByPercentage(2.5);
 shape.Draw();
 }
 }
 }

```

### 用generics類庫的C#

  

```
 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<T> : 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)
 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) {
 IShape[] shapes = new IShape[2];
 shapes[0] = new CircleShape<DrawingAPI1>(1, 2, 3);
 shapes[1] = new CircleShape<DrawingAPI2>(5, 7, 11);
 
 foreach (IShape shape in shapes) {
 shape.ResizeByPercentage(2.5);
 shape.Draw();
 }
 }
 }

```

  

### C++

  

```
#include <iostream>

using namespace std;

/\* Implementor\*/
class DrawingAPI {
 public:
 virtual void drawCircle(double x, double y, double radius) = 0;
 virtual ~DrawingAPI() {}
};

/\* 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 ~Shape() {}
 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) :
 m\_x(x), m\_y(y), m\_radius(radius), m\_drawingAPI(drawingAPI)
 {}
 void draw() {
 m\_drawingAPI->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,&dap1);
 CircleShape circle2(5,7,11,&dap2);
 circle1.resizeByPercentage(2.5);
 circle2.resizeByPercentage(2.5);
 circle1.draw();
 circle2.draw();
 return 0;
}

```

### Python

  

```
# Implementor
class DrawingAPI:
	def drawCircle(x, y, radius):
		pass

# ConcreteImplementor 1/2
class DrawingAPI1(DrawingAPI):
	def drawCircle(self, x, y, radius):
		print "API1.circle at %f:%f radius %f" % (x, y, radius)

# ConcreteImplementor 2/2
class DrawingAPI2(DrawingAPI):
	def drawCircle(self, x, y, radius):
		print "API2.circle at %f:%f radius %f" % (x, y, radius)

# Abstraction
class Shape:
	# low-level
	def draw(self):
		pass

	# high-level
	def resizeByPercentage(self, pct):
		pass

# Refined Abstraction
class CircleShape(Shape):
	def \_\_init\_\_(self, x, y, radius, drawingAPI):
		self.\_\_x = x
		self.\_\_y = y
		self.\_\_radius = radius
		self.\_\_drawingAPI = drawingAPI

	# low-level i.e. Implementation specific
	def draw(self):
		self.\_\_drawingAPI.drawCircle(self.\_\_x, self.\_\_y, self.\_\_radius)

	# high-level i.e. Abstraction specific
	def resizeByPercentage(self, pct):
		self.\_\_radius \*= pct

def main():
	shapes = [
		CircleShape(1, 2, 3, DrawingAPI1()),
		CircleShape(5, 7, 11, DrawingAPI2())
	]

	for shape in shapes:
		shape.resizeByPercentage(2.5)
		shape.draw()

if \_\_name\_\_ == "\_\_main\_\_":
	main()

```

  


|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
软件设计模式 |
| --- |
|  |
| 设计模式 | 

|  |  |
| --- | --- |
| 创建型 | 
* 抽象工厂
* 生成器
* 工厂方法
* 惰性初始
* 原型
* 单例

 |
|  |
| 结构型 | 
* 适配器
* 桥接
* Composite（英语：）
* 修饰
* 外观
* 享元
* 代理

 |
|  |
| 行为型 | 
* 责任链
* 命令
* Interpreter（英语：）
* 迭代器
* 中介者
* Memento（英语：）
* 观察者
* Specification（英语：）
* State（英语：）
* 策略
* 模板方法
* 访问者

 |

 |
|  |
| 并行模式 | 
* 主动对象（英语：）
* 阻止（英语：）
* Binding properties（英语：）
* 双重检查锁定模式
* 异步方法调用
* Future与promise
* Guarded suspension（英语：）
* Join（英语：）
* 锁
* Messaging（英语：）
* 监视器
* Proactor（英语：）
* 反应器
* 读写锁
* 调度
* 线程池
* 线程局部存储

 |
|  |
| 架构模式 | 
* ADR（英语：）
* 主动记录
* Broker（英语：）
* 主從式架構
* cbd
* DAO
* DDD
* Data transfer object（英语：）
* Front controller（英语：）
* Identity map（英语：）
* Interceptor（英语：）
* 控制反转
* MVC
* 微服務
* MVP
* 單體式應用程式
* 多层架构
* *n*-tier（英语：）
* Naked objects（英语：）
* P2P
* 发布/订阅
* REST
* SOA
* Specification（英语：）

 |
|  |
| 云分布式 | 
* 断路器
* CQRS（英语：）
* 补偿交易（英语：）
* 索引表
* 领导者选举（英语：）
* MapReduce
* 物化视图（英语：）
* 管道
* 过滤器（英语：）
* 发布/订阅
* 分片（英语：）
* 节流（英语：）

 |
|  |
| 其他模式 | 
* Blackboard（英语：）
* Business delegate（英语：）
* Composite entity（英语：）
* 委托
* 依赖注入
* Intercepting filter（英语：）
* 惰性載入
* Method chaining（英语：）
* 模拟对象
* 空对象
* 对象池
* Servant（英语：）
* Twin（英语：）
* Type tunnel（英语：）

 |
|  |
| 书籍 | 
* 设计模式：可复用面向对象软件的基础
* 企业集成模式（英语：）

 |
|  |
| 人物 | 
* 克里斯托佛·亚历山大
* 埃里希·伽瑪
* Ralph Johnson（英语：）
* John Vlissides（英语：）
* 葛來迪·布區
* 肯特·貝克
* 沃德·坎宁安
* 马丁·福勒
* Robert Martin（英语：）
* Jim Coplien（英语：）
* Douglas Schmidt（英语：）
* Linda Rising

 |
|  |
| 社区 | 
* The Hillside Group（英语：）
* The Portland Pattern Repository（英语：）

 |

 |