桥接模式

桥接模式是软件设计模式中最复杂的模式之一，它把事物对象和其具体行为、具体特征分离开来，使它们可以各自独立的变化。事物对象仅是一个抽象的概念。如“圆形”、“三角形”归于抽象的“形状”之下，而“画圆”、“画三角”归于实现行为的“画图”类之下，然后由“形状”调用“画图”。

**结构**
600px
 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 Shape2;
shapes0 = new CircleShape(1, 2, 3, new DrawingAPI1());
shapes1 = 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 IShape2;
shapes0 = new CircleShape(1, 2, 3, new DrawingAPI1());
shapes1 = 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 : 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 IShape2;
shapes0 = new CircleShape(1, 2, 3);
shapes1 = new CircleShape(5, 7, 11);

foreach (IShape shape in shapes) {
shape.ResizeByPercentage(2.5);
shape.Draw();
}
}
}

**C++**
#include 
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 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()