【图解设计模式】Bridge模式

Posted on | In

在“类的功能层次结构”和“类的实现层次结构”之间搭建桥梁。

  • 父类具有基本功能
  • 在子类中增加新的功能

这种层次结构被称为“类的功能层次结构”。

  • 父类通过声明抽象方法来定义接口（API）
  • 子类通过实现具体方法来实现接口（API）

这种层次结构被称为“类的实现层次结构”。

示例

显示一些东西。

类图

eywkJ1.png

Display类

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
public class Display {
    private DisplayImpl impl;

    public Display(DisplayImpl impl) {
        this.impl = impl;
    }

    public void open() {
        impl.rawOpen();
    }

    public void print() {
        impl.rawPrint();
    }

    public void close() {
        impl.rawClose();
    }

    public final void display() {
        open();
        print();
        close();
    }
}

CountDisplay类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class CountDisplay extends Display {
    public CountDisplay(DisplayImpl impl) {
        super(impl);
    }

    public void multiDisplay(int times) {
        open();

        for (int i = 0; i < times; i++)
            print();

        close();
    }
}

DisplayImpl类

1
2
3
4
5
public abstract class DisplayImpl {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
}

StringDisplayImpl类

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
public class StringDisplayImpl extends DisplayImpl {
    private String string;
    private int width;

    public StringDisplayImpl(String string) {
        this.string = string;
        this.width = string.getBytes().length;
    }

    @Override
    public void rawOpen() {
        printLine();
    }

    @Override
    public void rawPrint() {
        System.out.println("|" + string + "|");
    }

    @Override
    public void rawClose() {
        printLine();
    }

    private void printLine() {
        System.out.print("+");

        for (int i = 0; i < width; i++)
            System.out.print("-");

        System.out.println("+");
    }
}

Main类

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {

    public static void main(String[] args) {
        Display d1 = new Display(new StringDisplayImpl("Hello, China."));
        Display d2 = new CountDisplay(new StringDisplayImpl("Hello, World."));
        CountDisplay d3 = new CountDisplay(new StringDisplayImpl("Hello, Universe."));

        d1.display();
        d2.display();
        d3.display();
        d3.multiDisplay(5);
    }
}

运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
+-------------+
|Hello, China.|
+-------------+
+-------------+
|Hello, World.|
+-------------+
+----------------+
|Hello, Universe.|
+----------------+
+----------------+
|Hello, Universe.|
|Hello, Universe.|
|Hello, Universe.|
|Hello, Universe.|
|Hello, Universe.|
+----------------+

登场角色

Abstraction（抽象化）

该角色位于“类的功能层次结构”的最上层。它使用Implementor角色的方法定义了基本的功能。该角色中保存了Implementor角色的实例。在示例程序中，由Display类扮演此角色。

RefinedAbstraction（改善后的抽象化）

在Abstraction角色的基础上增加了新功能的角色。在示例程序中，由CountDisplay类扮演此角色。

Implementor（实现者）

该角色位于“类的实现层次结构”的最上层。它定义了用于实现Abstraction角色的接口（API）的方法。在示例程序中，由DisplayImpl类扮演此角色。

ConcreteImplementor（具体实现者）

该角色负责实现Implementor角色中定义的接口（API）。在示例程序中，由StringDisplayImpl类扮演此角色。

类图

eyB0x0.png