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