橋接模式

結構

Abstraction

Refined Abstraction

Implementor

ConcreteImplementor

示例

```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)
{
}
}

/** "ConcreteImplementor" 2/2 */
class DrawingAPI2 implements DrawingAPI
{
public void drawCircle(double x, double y, double radius)
{
}
}

/** "Abstraction" */
interface Shape
{
public void draw();                                            // low-level
public void resizeByPercentage(double pct);     // high-level
}

/** "Refined Abstraction" */
class CircleShape implements Shape
{
private DrawingAPI drawingAPI;
public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI)
{
this.drawingAPI = drawingAPI;
}

// low-level i.e. Implementation specific
public void draw()
{
}
// high-level i.e. Abstraction specific
public void resizeByPercentage(double 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)
{
}
}

/** "ConcreteImplementor" 2/2 */
class DrawingAPI2 : IDrawingAPI
{
public void DrawCircle(double x, double y, double 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 IDrawingAPI drawingAPI;
public CircleShape(double x, double y, double radius, IDrawingAPI drawingAPI)
{
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)
{
}
}

/** "ConcreteImplementor" 2/2 */
struct DrawingAPI2 : IDrawingAPI
{
public void DrawCircle(double x, double y, double 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 static IDrawingAPI drawingAPI = new T();
public CircleShape(double x, double y, double 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) :
{}
void draw() {
}
void resizeByPercentage(double pct) {
}
private:
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:
pass

# ConcreteImplementor 1/2
class DrawingAPI1(DrawingAPI):

# ConcreteImplementor 2/2
class DrawingAPI2(DrawingAPI):

# 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.__drawingAPI = drawingAPI

# low-level i.e. Implementation specific
def draw(self):

# high-level i.e. Abstraction specific
def resizeByPercentage(self, 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()
```