Java

Wyjście: API1.circle at 1.000000:2.000000 radius 7.500000 API2.circle at 5.000000:7.000000 radius 27.500000

import java.util.*;

/** "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; shapes = new CircleShape(1, 2, 3, new DrawingAPI1()); shapes = new CircleShape(5, 7, 11, new DrawingAPI2());

for (Shape shape : shapes) { shape.resizeByPercentage(2.5); shape.draw();

C++

#include

using namespace std; //For brevity.

//Implementor class DrawingAPI { public: virtual void DrawCircle(const double x, const double y, const double radius) = 0; virtual void DrawSquare(const double x, const double y) = 0;

// ConcreteImplementor 1/2 class OpenGL : public DrawingAPI { public: void DrawCircle(const double x, const double y, const double radius)

cout<<"OpenGL based circle drawn at "<<x<<":"<<y<<" radius "<<radius<<endl;

void DrawSquare(const double x, const double y)

cout<<"OpenGL based square drawn at "<<x<<":"<<y<<endl;

// ConcreteImplementor 2/2 class DirectX : public DrawingAPI { public: void DrawCircle(const double x, const double y, const double radius)

cout<<"DirectX based circle drawn at "<<x<<":"<<y<<" radius "<<radius<<endl;

void DrawSquare(const double x, const double y)

cout<<"DirectX based square drawn at "<<x<<":"<<y<<endl;

//Abstraction" class Shape { public: //Constrctor Shape(double x, double y, double radius, DrawingAPI* da) : _x(x), _y(y), _radius(radius), _da(da)

Shape(double x, double y, DrawingAPI* da) : _x(x), _y(y), _da(da)

public: // low-level virtual void Draw() = 0; protected: void DrawCircle()

_da->DrawCircle(_x, _y, _radius);

void DrawSquare()

_da->DrawSquare(_x, _y);

// high-level // This needs to be refined in the Refined Abstraction classes. virtual void ResizeByPercentage(double const pct) = 0; protected: double _x, _y, _radius; DrawingAPI* _da; // Shapes could be displayed by different DrawingAPI's.

//Refined Abstraction: define a Circle. class Circle : public Shape { public : //Constructor Circle(double x, double y, double radius, DrawingAPI* da) : Shape(x, y, radius, da)

public: //Behavior // low-level i.e. Implementation specific. // Draw doesn't even know what parameters it's using and WHO is drawing it. void Draw() { DrawCircle(); } // High-level i.e. Abstraction specific. // A circle has a radius, but a square has a length (for example). void ResizeByPercentage(const double pct) { _radius *= pct; }

//Refined Abstraction: define a Square. class Square : public Shape { public : //Constructor Square(double x, double y, DrawingAPI* da) : Shape(x, y, da)

public: //Behavior // Low-level i.e. Implementation specific. // Draw doesn't even know what parameters it's using and WHO is drawing it. void Draw() { DrawSquare(); } // High-level i.e. Abstraction specific. // A circle has a radius, but a square has a length (for example). void ResizeByPercentage(const double pct) { _x *= pct; }

//The Client. // -->> int main() merely demonstrates the interchangebility. int main() { Shape* TheShape; //2 shapes x 2 implementations = 4 client-options. DrawingAPI* DA; //2 Implementations. DA = new OpenGL; DA = new DirectX;

TheShape = new Circle(1, 2, 7.5, DA); //Draw circle with OpenGL TheShape->Draw();

TheShape = new Circle(5, 7, 27.5, DA); //Draw circle with DirectX TheShape->Draw();

TheShape = new Square(10, 14, DA); //Draw square with OpenGL TheShape->Draw();

TheShape = new Square(2.9, 80, DA); //Draw square with DirectX TheShape->Draw();

//Give back allocated memory. delete DA, DA; delete TheShape, TheShape, TheShape, TheShape;

return 0; }

C#

wyjście: API1.circle at 1:2 radius 7.5 API2.circle at 5:7 radius 27.5

using System;

/** "Implementor" */ interface DrawingAPI { void DrawCircle(double x, double y, double radius); }

/** "ConcreteImplementor" 1/2 */ class DrawingAPI1 : DrawingAPI { public void DrawCircle(double x, double y, double radius)

System.Console.WriteLine("API1.circle at {0}:{1} radius {2}\n", x, y, radius);

/** "ConcreteImplementor" 2/2 */ class DrawingAPI2 : DrawingAPI { public void DrawCircle(double x, double y, double radius)

System.Console.WriteLine("API2.circle at {0}:{1} radius {2}\n", x, y, radius);

/** "Abstraction" */ interface Shape { void Draw(); // low-level void ResizeByPercentage(double pct); // high-level }

/** "Refined Abstraction" */ class CircleShape : 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; shapes = new CircleShape(1, 2, 3, new DrawingAPI1()); shapes = new CircleShape(5, 7, 11, new DrawingAPI2());

foreach (Shape shape in shapes)

shape.ResizeByPercentage(2.5); shape.Draw();

Perl

wyjście: API1.circle at 1:2 radius 7.5 API2.circle at 5:7 radius 27.5

### ConcreteImplementor 1/2 package DrawingAPI1;

sub new { my $class = shift; return bless({}, $class); }

sub draw_circle { my($self, $x, $y, $radius) = @_;

print("API1.circle at $x:$y radius $radius\n"); }

1;

### ConcreteImplementor 2/2 package DrawingAPI2;

sub new { my $class = shift; return bless({}, $class); }

sub draw_circle { my($self, $x, $y, $radius) = @_;

print("API2.circle at $x:$y radius $radius\n"); }

1;

### Refined Abstraction package CircleShape;

sub new { my $class = shift; my ($x, $y, $radius, $drawing_api) = @_;

my $self = bless({ x => $x, y => $y, radius => $radius, drawing_api => $drawing_api, }, $class);

return $self; }

sub draw { my $self = shift; $self->{drawing_api}->draw_circle( $self->{x}, $self->{y}, $self->{radius}); }

sub resize_by_percentage { my($self, $percent) = @_; $self->{radius} *= $percent; }

1;

### client my @shapes = ( CircleShape->new(1, 2, 3, DrawingAPI1->new), CircleShape->new(5, 7, 11, DrawingAPI2->new), );

foreach my $shape (@shapes) { $shape->resize_by_percentage(2.5); $shape->draw(); }

PHP wyjście: API1.circle at 1:2 radius 7.5 API2.circle at 5:7 radius 27.5

<?php /** "Implementor" */ interface DrawingAPI { public function drawCircle($x, $y, $radius);

/** "ConcreteImplementor" 1/2 */ class DrawingAPI1 implements DrawingAPI{ public function drawCircle($x, $y, $radius) { echo "API1.circle at $x:$y radius $radius\n"; }

/** "ConcreteImplementor" 2/2 */ class DrawingAPI2 implements DrawingAPI { public function drawCircle($x, $y, $radius) { echo "API2.circle at $x:$y radius $radius\n"; }

/** "Abstraction" */ interface Shape { public function draw(); // low-level public function resizeByPercentage($pct); // high-level

/** "Refined Abstraction" */ class CircleShape implements Shape { private $x; private $y; private $radius; private $drawingAPI; public function __construct($x, $y, $radius, DrawingAPI $drawingAPI) { $this->x = $x; $this->y = $y; $this->radius = $radius; $this->drawingAPI = $drawingAPI;

// low-level i.e. Implementation specific public function draw() { $this->drawingAPI->drawCircle($this->x, $this->y, $this->radius); } // high-level i.e. Abstraction specific public function resizeByPercentage($pct) { $this->radius *= $pct; }

/** "Client" */ $shapes = array(); $shapes[] = new CircleShape(1, 2, 3, new DrawingAPI1()); $shapes[] = new CircleShape(5, 7, 11, new DrawingAPI2());

foreach ($shapes as $shape) { $shape->resizeByPercentage(2.5); $shape->draw(); } ?>

Python wyjście: API1.circle at 1.000000:2.000000 radius 7.500000 API2.circle at 5.000000:7.000000 radius 27.500000

class CircleShape: def __init__(self,x,y,r,da): self.x = x self.y = y self.r = r self.da = da def draw(self): self.da.drawCircle(self.x,self.y,self.r) def resizeByPercentage(self,pct): self.r *= pct

class DrawingAPI2: def drawCircle(self,x,y,r): print "API2.circle at %f:%f radius %f" % (x,y,r)

class DrawingAPI1: def drawCircle(self,x,y,r): print "API1.circle at %f:%f radius %f" % (x,y,r)

if __name__ == '__main__': shapes = [CircleShape(1,2,3,DrawingAPI1()), CircleShape(5,7,11,DrawingAPI2())] for shape in shapes: shape.resizeByPercentage(2.5) shape.draw()

Ruby wyjście: API1.circle at 1.000000:2.000000 radius 7.500000 API2.circle at 5.000000:7.000000 radius 27.500000

class CircleShape def initialize(x, y, r, da) @x = x @y = y @r = r @da = da end def draw; @da.drawCircle(@x, @y, @r); end def resizeByPercentage(pct); @r *= pct; end end class DrawingAPI1 def drawCircle(x,y,r) printf "API1.circle at %f:%f radius %f", x, y, r end end class DrawingAPI2 def drawCircle(x,y,r) printf "API2.circle at %f:%f radius %f", x, y, r end end

shapes = [CircleShape.new(1, 2, 3, DrawingAPI1.new), CircleShape.new(5, 7, 11, DrawingAPI2.new)] shapes.each do |shape| shape.resizeByPercentage(2.5) shape.draw end