브리지 패턴

브리지 패턴(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 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)
 // high-level (i.e. Abstraction-specific)
 /** "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++.
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-&gt;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,&amp;dap1);
 CircleShape circle2(5,7,11,&amp;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
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
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.resizeByPercentage(2.5)
 shape1.draw()
 shape2.resizeByPercentage(2)
 shape2.draw()
Python3.
class DrawingAPI:
 def draw_circle(self, x, y, radius):
 pass
class DrawingAPI1(DrawingAPI):
 def draw_circle(self, x, y, radius):
 print(f"API1.circle at {x}:{y} {radius}")
class DrawingAPI2(DrawingAPI):
 def draw_circle(self, x, y, radius):
 print(f"API2.circle at {x}:{y} {radius}")
class Shape:
 def draw(self):
 pass
 def resize_by_percentage(pct):
 pass
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()