Java设计模式(九) 桥接模式

原创文章,转载请务必将下面这段话置于文章开头处(保留超链接)。
本文转发自Jason’s Blog原文链接 http://www.jasongj.com/design_pattern/bridge/

桥接模式定义

桥接模式(Bridge Pattern),将抽象部分与它的实现部分分离,使它们都可以独立地变化。更容易理解的表述是:实现系统可从多种维度分类,桥接模式将各维度抽象出来,各维度独立变化,之后可通过聚合,将各维度组合起来,减少了各维度间的耦合。

例讲桥接模式

不必要的继承导致类爆炸

汽车可按品牌分(本例中只考虑BMT,BenZ,Land Rover),也可按手动档、自动档、手自一体来分。如果对于每一种车都实现一个具体类,则一共要实现3*3=9个类。

使用继承方式的类图如下
Bridge pattern inherit class diagram

从上图可以看到,对于每种组合都需要创建一个具体类,如果有N个维度,每个维度有M种变化,则需要$M^N$个具体类,类非常多,并且非常多的重复功能。

如果某一维度,如Transmission多一种可能,比如手自一体档(AMT),则需要增加3个类,BMWAMT,BenZAMT,LandRoverAMT。

桥接模式类图

桥接模式类图如下
Bridge pattern class diagram

从上图可知,当把每个维度拆分开来,只需要M*N个类,并且由于每个维度独立变化,基本不会出现重复代码。

此时如果增加手自一体档,只需要增加一个AMT类即可

桥接模式实例解析

本文代码可从作者Github下载

抽象车

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package 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
16
package 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);

@Override
public void run() {
gear.gear();
LOG.info("BMW is running");
};

}

BenZCar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package 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);

@Override
public void run() {
gear.gear();
LOG.info("BenZCar is running");
};

}

LandRoverCar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package 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);

@Override
public void run() {
gear.gear();
LOG.info("LandRoverCar is running");
};

}

抽象变速器

1
2
3
4
5
6
7
package com.jasongj.transmission;

public abstract class Transmission{

public abstract void gear();

}

手动档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package 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);

@Override
public void gear() {
LOG.info("Manual transmission");
}
}

自动档

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package 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);

@Override
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
25
package 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

Java设计模式系列

郭俊 Jason wechat
欢迎关注作者微信公众号【大数据架构】
您的赞赏将支持作者继续原创分享