设计模式(18)——桥接模式

本文介绍桥接模式的概念和应用。

基本思想和原则

将抽象和实现解耦,使得两者可以独立地变化。

动机

当抽象和具体实现无法很好契合时,使用继承会导致产生过多的类,此时可以考虑使用桥接模式,使用聚合的方式来连接抽象和具体实现。另外当对重用性有较高要求时也可以使用桥接模式。

实现

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
public abstract class Factory {
IElectronicProduct electronicProduct;

public Factory(IElectronicProduct electronicProduct) {
this.electronicProduct = electronicProduct;
}

public void produce() {
this.electronicProduct.beProduced();
}

public IElectronicProduct getElectronicProduct() {
return this.electronicProduct;
}
}

public class ElectronicProductFactory extends Factory {
public ElectronicProductFactory(IElectronicProduct electronicProduct) {
super(electronicProduct);
}

@Override
public void produce() {
super.produce();
super.getElectronicProduct().beUsed();
}
}

public interface IElectronicProduct {
public void beProduced();
public void beUsed();
}

public class Radio implements IElectronicProduct {
@Override
public void beProduced() {
System.out.println("Radio be produced.");
}

@Override
public void beUsed() {
System.out.println("Radio be used.");
}
}

public class Television implements IElectronicProduct {
@Override
public void beProduced() {
System.out.println("Television be produced.");
}

@Override
public void beUsed() {
System.out.println("Television be used.");
}
}

public class Test {
public static void main(String[] args) {
Factory electronicProductFactory1 = new ElectronicProductFactory(new Radio());
electronicProductFactory1.produce();

Factory electronicProductFactory2 = new ElectronicProductFactory(new Television());
electronicProductFactory2.produce();
}
}

输出如下:

1
2
3
4
Radio be produced.
Radio be used.
Television be produced.
Television be used.

上面代码模拟了一个工厂生产电子产品的场景,抽象类Factory内部聚合了一个实现了IElectronicProduct接口的类的对象,我们可以自由增加具体的产品类,只要实现了IElectronicProduct这个接口即可。同样只要抽象层和具体实现之间的接口不变,这里指的是Factory类的produce方法,抽象层和具体实现就可以各自独立变化互不影响。

优点

桥接模式通过将抽象层聚合具体实现的方式来将抽象和实现分离,使二者可以独立扩展。另外封装了具体实现,使之不会暴露给外部,具有很好的封装性。