原创文章，转载请务必将下面这段话置于文章开头处（保留超链接）。
本文转发自技术世界，原文链接 http://www.jasongj.com/design_pattern/bridge/
桥接模式定义
桥接模式（Bridge Pattern），将抽象部分与它的实现部分分离，使它们都可以独立地变化。更容易理解的表述是：实现系统可从多种维度分类，桥接模式将各维度抽象出来，各维度独立变化，之后可通过聚合，将各维度组合起来，减少了各维度间的耦合。
例讲桥接模式
不必要的继承导致类爆炸
汽车可按品牌分（本例中只考虑BMT，BenZ，Land Rover），也可按手动档、自动档、手自一体来分。如果对于每一种车都实现一个具体类，则一共要实现3*3=9个类。
使用继承方式的类图如下
从上图可以看到，对于每种组合都需要创建一个具体类，如果有N个维度，每个维度有M种变化，则需要$M^N$个具体类，类非常多，并且非常多的重复功能。
如果某一维度，如Transmission多一种可能，比如手自一体档（AMT），则需要增加3个类，BMWAMT，BenZAMT，LandRoverAMT。
桥接模式类图
桥接模式类图如下
从上图可知，当把每个维度拆分开来，只需要M*N个类，并且由于每个维度独立变化，基本不会出现重复代码。
此时如果增加手自一体档，只需要增加一个AMT类即可
桥接模式实例解析
本文代码可从作者Github下载
抽象车1
2
3
4
5
6
7
8
9
10
11
12
13
14
15package com.jasongj.brand;
import com.jasongj.transmission.Transmission;
public abstract class AbstractCar {
protected Transmission gear;
public abstract void run();
public void setTransmission(Transmission gear) {
this.gear = gear;
}
}
按品牌分，BMW牌车1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16package com.jasongj.brand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BMWCar extends AbstractCar{
private static final Logger LOG = LoggerFactory.getLogger(BMWCar.class);
public void run() {
gear.gear();
LOG.info("BMW is running");
};
}
BenZCar1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16package com.jasongj.brand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BenZCar extends AbstractCar{
private static final Logger LOG = LoggerFactory.getLogger(BenZCar.class);
public void run() {
gear.gear();
LOG.info("BenZCar is running");
};
}
LandRoverCar1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16package com.jasongj.brand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LandRoverCar extends AbstractCar{
private static final Logger LOG = LoggerFactory.getLogger(LandRoverCar.class);
public void run() {
gear.gear();
LOG.info("LandRoverCar is running");
};
}
抽象变速器1
2
3
4
5
6
7package com.jasongj.transmission;
public abstract class Transmission{
public abstract void gear();
}
手动档1
2
3
4
5
6
7
8
9
10
11
12
13
14package com.jasongj.transmission;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Manual extends Transmission {
private static final Logger LOG = LoggerFactory.getLogger(Manual.class);
public void gear() {
LOG.info("Manual transmission");
}
}
自动档1
2
3
4
5
6
7
8
9
10
11
12
13
14package com.jasongj.transmission;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Auto extends Transmission {
private static final Logger LOG = LoggerFactory.getLogger(Auto.class);
public void gear() {
LOG.info("Auto transmission");
}
}
有了变速器和品牌两个维度各自的实现后，可以通过聚合，实现不同品牌不同变速器的车，如下1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25package com.jasongj.client;
import com.jasongj.brand.AbstractCar;
import com.jasongj.brand.BMWCar;
import com.jasongj.brand.BenZCar;
import com.jasongj.transmission.Auto;
import com.jasongj.transmission.Manual;
import com.jasongj.transmission.Transmission;
public class BridgeClient {
public static void main(String[] args) {
Transmission auto = new Auto();
AbstractCar bmw = new BMWCar();
bmw.setTransmission(auto);
bmw.run();
Transmission manual = new Manual();
AbstractCar benz = new BenZCar();
benz.setTransmission(manual);
benz.run();
}
}
桥接模式与OOP原则
已遵循的原则
- 依赖倒置原则
- 迪米特法则
- 里氏替换原则
- 接口隔离原则
- 单一职责原则
- 开闭原则
未遵循的原则
- NA
