Bridgeパターン（デザインパターン）調査レポート

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 悪い例（継承による階層爆発）
Shape
├── Circle
│   ├── RedCircle
│   └── BlueCircle
└── Rectangle
    ├── RedRectangle
    └── BlueRectangle

# 良い例（Bridgeパターン）
Shape (Abstraction)          Color (Implementor)
├── Circle                   ├── Red
└── Rectangle                └── Blue

# 4つのクラスで6通りの組み合わせに対応可能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 悪い例：継承による階層爆発
class WindowsButton extends Button { }
class LinuxButton extends Button { }
class MacButton extends Button { }
class WindowsCheckbox extends Checkbox { }
class LinuxCheckbox extends Checkbox { }
class MacCheckbox extends Checkbox { }
// ... UIコンポーネント × プラットフォーム数だけクラスが増える

// 良い例：Bridgeパターン
abstract class UIComponent {
    protected Renderer renderer; // Bridge
}
interface Renderer {
    void render();
}
class WindowsRenderer implements Renderer { }
class LinuxRenderer implements Renderer { }
// 新しいUIコンポーネントや新しいプラットフォームを独立して追加可能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Abstraction側：
- Button（ボタン）
- Window（ウィンドウ）
- TextBox（テキストボックス）

Implementation側：
- WindowsRenderer
- LinuxRenderer
- MacRenderer

# 同じButtonクラスでも、実行時に適切なRendererに委譲することで
# 各プラットフォームのネイティブUIとして描画される

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Abstraction側：
- FileSystem（ファイルシステム）
- NetworkProtocol（ネットワークプロトコル）

Implementation側：
- USBDriver
- PrinterDriver
- SerialDriver

# OSの上位層は共通APIでデバイスにアクセスし、
# 実際のハードウェア制御は各ドライバが担当

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Abstraction側：
- DataAccessLayer（データアクセス層）
- RepositoryPattern（リポジトリ）

Implementation側：
- MySQLDriver
- PostgreSQLDriver
- OracleDriver
- MongoDBDriver

# アプリケーションコードは共通のデータアクセスAPIを使用し、
# 実際のSQL実行やクエリ最適化は各ドライバが担当

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

Abstraction側：
- Shape（形状）
  - Circle
  - Rectangle
  - Triangle

Implementation側：
- OpenGLRenderer
- DirectXRenderer
- VulkanRenderer

# 同じShapeオブジェクトでも、使用するレンダラーに応じて
# 異なるグラフィックスAPIで描画される

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;

# Implementor（実装者）インターフェース
package Color;

sub new {
    my $class = shift;
    die "Abstract class";
}

sub apply_color {
    die "Abstract method";
}

# ConcreteImplementor（具体的な実装者）
package RedColor;
use parent 'Color';

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

sub apply_color {
    my $self = shift;
    return "赤色";
}

package BlueColor;
use parent 'Color';

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

sub apply_color {
    my $self = shift;
    return "青色";
}

# Abstraction（抽象）
package Shape;

sub new {
    my ($class, $color) = @_;
    return bless { color => $color }, $class;
}

sub draw {
    die "Abstract method";
}

# RefinedAbstraction（洗練された抽象）
package Circle;
use parent 'Shape';

sub draw {
    my $self = shift;
    my $color_str = $self->{color}->apply_color();
    say "${color_str}の円を描画します";
}

package Rectangle;
use parent 'Shape';

sub draw {
    my $self = shift;
    my $color_str = $self->{color}->apply_color();
    say "${color_str}の四角形を描画します";
}

# クライアント
package main;

my $red = RedColor->new();
my $blue = BlueColor->new();

my $red_circle = Circle->new($red);
my $blue_circle = Circle->new($blue);
my $red_rectangle = Rectangle->new($red);
my $blue_rectangle = Rectangle->new($blue);

$red_circle->draw();        # 赤色の円を描画します
$blue_circle->draw();       # 青色の円を描画します
$red_rectangle->draw();     # 赤色の四角形を描画します
$blue_rectangle->draw();    # 青色の四角形を描画します

1
2
3
4

赤色の円を描画します
青色の円を描画します
赤色の四角形を描画します
青色の四角形を描画します

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;

# Implementor（実装者）ロール
package Renderer {
    use Moose::Role;
    requires 'render_circle';
}

# ConcreteImplementor（具体的な実装者）
package VectorRenderer {
    use Moose;
    with 'Renderer';
    
    sub render_circle {
        my ($self, $radius) = @_;
        say "ベクターで半径 ${radius} の円を描画";
    }
}

package RasterRenderer {
    use Moose;
    with 'Renderer';
    
    sub render_circle {
        my ($self, $radius) = @_;
        say "ラスターで半径 ${radius} の円をピクセル描画";
    }
}

# Abstraction（抽象）
package Shape {
    use Moose;
    
    has 'renderer' => (
        is       => 'ro',
        does     => 'Renderer',
        required => 1,
    );
}

# RefinedAbstraction（洗練された抽象）
package Circle {
    use Moose;
    extends 'Shape';
    
    has 'radius' => (
        is       => 'ro',
        isa      => 'Num',
        required => 1,
    );
    
    sub draw {
        my $self = shift;
        $self->renderer->render_circle($self->radius);
    }
}

# クライアント
package main;

my $vector = VectorRenderer->new();
my $raster = RasterRenderer->new();

my $circle1 = Circle->new(radius => 5, renderer => $vector);
my $circle2 = Circle->new(radius => 10, renderer => $raster);

$circle1->draw();  # ベクターで半径 5 の円を描画
$circle2->draw();  # ラスターで半径 10 の円をピクセル描画

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// Implementor（実装者）インターフェース
interface Workshop {
    void work();
}

// ConcreteImplementor（具体的な実装者）
class Produce implements Workshop {
    public void work() {
        System.out.print("生産");
    }
}

class Assemble implements Workshop {
    public void work() {
        System.out.print("組み立て");
    }
}

// Abstraction（抽象）
abstract class Vehicle {
    protected Workshop workShop1;
    protected Workshop workShop2;
    
    protected Vehicle(Workshop w1, Workshop w2) {
        this.workShop1 = w1;
        this.workShop2 = w2;
    }
    
    abstract public void manufacture();
}

// RefinedAbstraction（洗練された抽象）
class Car extends Vehicle {
    public Car(Workshop w1, Workshop w2) {
        super(w1, w2);
    }
    
    public void manufacture() {
        System.out.print("自動車 ");
        workShop1.work();
        System.out.print(" して ");
        workShop2.work();
        System.out.println(" しました。");
    }
}

class Bike extends Vehicle {
    public Bike(Workshop w1, Workshop w2) {
        super(w1, w2);
    }
    
    public void manufacture() {
        System.out.print("バイク ");
        workShop1.work();
        System.out.print(" して ");
        workShop2.work();
        System.out.println(" しました。");
    }
}

// クライアント
public class BridgePatternDemo {
    public static void main(String[] args) {
        Vehicle car = new Car(new Produce(), new Assemble());
        car.manufacture();
        // 出力: 自動車 生産 して 組み立て しました。
        
        Vehicle bike = new Bike(new Produce(), new Assemble());
        bike.manufacture();
        // 出力: バイク 生産 して 組み立て しました。
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111

// Implementor（実装者）インターフェース
interface Device {
  isEnabled(): boolean;
  enable(): void;
  disable(): void;
  getVolume(): number;
  setVolume(percent: number): void;
}

// ConcreteImplementor（具体的な実装者）
class TV implements Device {
  private on: boolean = false;
  private volume: number = 30;

  isEnabled(): boolean {
    return this.on;
  }

  enable(): void {
    this.on = true;
    console.log("TV: オンにしました");
  }

  disable(): void {
    this.on = false;
    console.log("TV: オフにしました");
  }

  getVolume(): number {
    return this.volume;
  }

  setVolume(percent: number): void {
    this.volume = Math.max(0, Math.min(percent, 100));
    console.log(`TV: 音量を ${this.volume}% に設定しました`);
  }
}

class Radio implements Device {
  private on: boolean = false;
  private volume: number = 50;

  isEnabled(): boolean {
    return this.on;
  }

  enable(): void {
    this.on = true;
    console.log("ラジオ: オンにしました");
  }

  disable(): void {
    this.on = false;
    console.log("ラジオ: オフにしました");
  }

  getVolume(): number {
    return this.volume;
  }

  setVolume(percent: number): void {
    this.volume = Math.max(0, Math.min(percent, 100));
    console.log(`ラジオ: 音量を ${this.volume}% に設定しました`);
  }
}

// Abstraction（抽象）
class RemoteControl {
  protected device: Device;

  constructor(device: Device) {
    this.device = device;
  }

  togglePower(): void {
    if (this.device.isEnabled()) {
      this.device.disable();
    } else {
      this.device.enable();
    }
  }

  volumeDown(): void {
    this.device.setVolume(this.device.getVolume() - 10);
  }

  volumeUp(): void {
    this.device.setVolume(this.device.getVolume() + 10);
  }
}

// RefinedAbstraction（洗練された抽象）
class AdvancedRemoteControl extends RemoteControl {
  mute(): void {
    console.log("リモコン: ミュートします");
    this.device.setVolume(0);
  }
}

// クライアント
const tv = new TV();
const remote = new RemoteControl(tv);
remote.togglePower();  // TV: オンにしました
remote.volumeUp();     // TV: 音量を 40% に設定しました
remote.volumeUp();     // TV: 音量を 50% に設定しました

const radio = new Radio();
const advancedRemote = new AdvancedRemoteControl(radio);
advancedRemote.togglePower();  // ラジオ: オンにしました
advancedRemote.mute();         // リモコン: ミュートします
                                // ラジオ: 音量を 0% に設定しました

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

from abc import ABC, abstractmethod

# Implementor（実装者）インターフェース
class Renderer(ABC):
    @abstractmethod
    def render_circle(self, radius: float) -> None:
        pass

# ConcreteImplementor（具体的な実装者）
class VectorRenderer(Renderer):
    def render_circle(self, radius: float) -> None:
        print(f"ベクターで半径 {radius} の円を描画")

class RasterRenderer(Renderer):
    def render_circle(self, radius: float) -> None:
        print(f"ラスターで半径 {radius} の円をピクセル描画")

# Abstraction（抽象）
class Shape:
    def __init__(self, renderer: Renderer):
        self.renderer = renderer
    
    @abstractmethod
    def draw(self) -> None:
        pass

# RefinedAbstraction（洗練された抽象）
class Circle(Shape):
    def __init__(self, renderer: Renderer, radius: float):
        super().__init__(renderer)
        self.radius = radius
    
    def draw(self) -> None:
        self.renderer.render_circle(self.radius)

# クライアント
if __name__ == "__main__":
    vector = VectorRenderer()
    raster = RasterRenderer()
    
    circle1 = Circle(vector, 5)
    circle2 = Circle(raster, 10)
    
    circle1.draw()  # ベクターで半径 5 の円を描画
    circle2.draw()  # ラスターで半径 10 の円をピクセル描画

1
2

新しい形状を追加 → 色の実装には影響なし
新しい色を追加 → 形状の実装には影響なし

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 新しい色を追加（既存のShapeクラスは変更不要）
class GreenColor implements Color {
    public String applyColor() {
        return "緑色";
    }
}

// 新しい形状を追加（既存のColorクラスは変更不要）
class Triangle extends Shape {
    public void draw() {
        System.out.println(color.applyColor() + "の三角形");
    }
}

1
2
3
4
5
6
7

# 実行時に実装を切り替え可能
my $shape = Circle->new($red_color);
$shape->draw();  # 赤色の円

# 色を動的に変更
$shape->{color} = $blue_color;
$shape->draw();  # 青色の円

1
2

Bridge: GUIフレームワーク設計時に、UIコンポーネントとプラットフォームを分離
Adapter: レガシーAPIを新システムに統合する際にラッパーを作成