브리지 패턴

**브리지 패턴**(Bridge pattern)이란 구현부에서 추상층을 분리하여 각자 독립적으로 변형할 수 있게 하는 패턴이다.

## 구조

750px|구조

## 코드 예
### 자바


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


```csharp
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();
        }
    }
 }
```


### [[C++]]


```cpp
#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;
}
```


### GO


```go
package main

import (
	"fmt"
)

// Implementor
type DrawingAPI interface {
	drawCircle(float32, float32, float32)
}

// ConcreteImplementor 1/2
type DrawingAPI1 struct{}

func (d *DrawingAPI1) drawCircle(x float32, y float32, radius float32) {
	fmt.Printf("API1.circle at %f:%f radius %f\n", x, y, radius)
}

// ConcreteImplementor 2/2
type DrawingAPI2 struct{}

func (d *DrawingAPI2) drawCircle(x float32, y float32, radius float32) {
	fmt.Printf("API2.circle at %f:%f radius %f\n", x, y, radius)
}

// Abstraction
type Shape interface {
	draw()
	resizeByPercentage(float32)
}

// Refined Abstraction
type CircleShape struct {
	x, y, radius float32
	drawingAPI   DrawingAPI
}

// Implementation specific
func (c *CircleShape) draw() {
	c.drawingAPI.drawCircle(c.x, c.y, c.radius)
}

// Abstraction specific
func (c *CircleShape) resizeByPercentage(pct float32) {
	c.radius *= pct
}

// Client
func main() {
	shape1 := &CircleShape{1, 2, 3, &DrawingAPI1{}}
	shape1.resizeByPercentage(2.5)
	shape1.draw()

	shape2 := &CircleShape{5, 7, 11, &DrawingAPI2{}}
	shape2.resizeByPercentage(2)
	shape2.draw()
}
```


### Python3

```python3
# Implementor
class DrawingAPI:
    def draw_circle(self, x, y, radius):
        pass

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

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

# Abstraction
class Shape:
    def draw(self):
        pass
    def resize_by_percentage(pct):
        pass

# Refined Abstraction
class CircleShape(Shape):
    x = 0
    y = 0
    radius = 0
    drawing_api = None

    def __init__(self, x, y, radius, drawing_api):
        self.x = x
        self.y = y
        self.radius = radius
        self.drawing_api = drawing_api

    def draw(self):
        self.drawing_api.draw_circle(self.x, self.y, self.radius)

    def resize_by_percentage(self, pct):
        self.radius *= pct

def main():
    dap1 = DrawingAPI1()
    dap2 = DrawingAPI2()
    circle1 = CircleShape(1, 2, 3, dap1)
    circle2 = CircleShape(5, 7, 11, dap2)
    circle1.resize_by_percentage(2.5)
    circle2.resize_by_percentage(2.5)
    circle1.draw()
    circle2.draw()

if __name__ == "__main__":
    main()
```

## 같이 보기
* 어댑터 패턴
* 전략 패턴
* 템플릿 메소드 패턴

분류:소프트웨어 디자인 패턴