브리지 패턴

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

**구조**
구조

**코드 예**

**자바**
/** "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();
}
}
}

**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;
}

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

**같이 보기**
 어댑터 패턴- 전략 패턴- 템플릿 메소드 패턴
분류:소프트웨어 디자인 패턴