bridge模式 java_设计模式--桥接(Bridge)模式

1.概述：

桥接模式：把抽象和行为分离开来，中间需要某个介质来连接抽象化和行为化。此模式的概述听起来非常像适配器模式，不要搞混了，虽然都是借用中间介质，但意义不同。最典型的桥接模式就是：JDBC。通过Connection来与不同的数据库进行连接，然后用DriverManager来管理。

2.例子：

我们哪车子来打比方，比如：车有很多中类型(Bus,Jeep,taxi等)，但每个车的引擎又不一样(有2000cc,2200cc)的；现在我们来造车，平常思维是根据车的配置来安装不同的引擎，而我们桥接模式的思维却是根据引擎来造车。

平常思维一：

/***造一个安装了引擎的车类接口*/

packagecom.msit.xxx;public interfaceCar {public void installEngine();//安装 引擎

}

1 /**

2 *造一个Bus的具体车类，但每种Bus的引擎我们是不能立即确定的3 */

4

5 packagecom.msit.xxx;6

7 /**

8 * 公交车：需要哪种引擎就要增加哪种子类9 *10 *@authoradmin11 *12 */

13 public abstract class Bus implementsCar {14

15 @Override16 public abstract void installEngine();//公交车又有2000cc发动机和2200cc发动机

17

18 }

1 packagecom.msit.xxx;2 /**

3 *造一辆2000cc的Bus4 */

5 public class Bus2000 extendsBus {6

7 @Override8 public voidinstallEngine() {9 System.err.println("这是2000cc发动机Bus");10 }11 }

/***造一辆2200cc的Bus*/

packagecom.msit.xxx;public class Bus2200 extendsBus {

@Overridepublic voidinstallEngine() {

System.out.println("这是2200cc发动机Bus");

}

}

packagecom.msit.xxx;public classMainClass {public static voidmain(String[] args) {/*** 生产一辆2000cc的Bus*/Car car1= newBus2000();

car1.installEngine();

}

}

这种实现方式的不足就是：每当我们的引擎或车的类型不确定时，或者增加(加一个1800cc的)引擎和车(造一辆吉普车)时，我们都需要写一个类实现Car，然后再继承具体车型；这样就会造成非常多的子类，显得项目非常的复杂。

平常思维二：

packagecom.msit.xxx2;/***我们在造车的时候一并把引擎造出来，这样当某个车型需要哪种引擎就引用这种引擎*/

public interfaceCar {//public void installEngine();原来的方法，产生一个总的引擎

public voidinstall2000Engine();public voidinstall2200Engine();

......其他引擎

}

packagecom.msit.xxx2;public class Bus implementsCar {/*** 造汽车时，把引擎造出来*/@Overridepublic voidinstall2000Engine() {

System.out.println("2000cc发动机Bus");

}

@Overridepublic voidinstall2200Engine() {

System.out.println("2200发动机Bus");

}

}

packagecom.msit.xxx2;/***生产汽车*/

public classMainClass {public static voidmain(String[] args) {

Car car= newBus();

car.install2000Engine();//需要哪种引擎公交车就装哪种

}

}

这种实现的特点就是：把子类具有的引擎集中在一起 ，需要哪种子类就增加哪种子类方法。但缺点时，有些引擎我们用不到却造出来了，这些方法就会变成一些冗余代码。

下面我们来用桥接模式做一下：

packagecom.msit.Birdge;/*** 总引擎 桥接模式：以前是根据汽车来分引擎，现在是根据引擎来分汽车

*

*@authoradmin

**/

public interfaceEngine {public voidinstallEngine();

}

packagecom.msit.Birdge;/***造一个具体的引擎*/

public class Engine2000 implementsEngine {

@Overridepublic voidinstallEngine() {

System.out.println("2000cc");

}

}

packagecom.msit.Birdge;public class Engine2200 implementsEngine {

@Overridepublic voidinstallEngine() {

System.out.println("2200cc");

}

}

packagecom.msit.Birdge;/*** 设为抽象类的目的，根据不同车来配置引擎

*

*@authoradmin

**/

public abstract classCar {private Engine engine;//调用总引擎

publicCar(Engine engine) {this.engine =engine;

}publicEngine getEngine() {returnengine;

}public voidsetEngine(Engine engine) {this.engine =engine;

}public abstract voidinstallEngine();

}

packagecom.msit.Birdge;/***开始设计车*/

public class Bus extendsCar {publicBus(Engine engine) {super(engine);

}

@Overridepublic voidinstallEngine() {

System.out.println("Bus:");this.getEngine().installEngine();//调用发动机，具体哪种发动机再安装的时候说明(使用Main方法的时候)

}

}

packagecom.msit.Birdge;/*** 开始生产

*

*@authoradmin

**/

public classMainClass {public static voidmain(String[] args) {//1.做一个具体的发动机出来

Engine engine2000 = newEngine2000();

Engine engine2200= newEngine2200();//2.做一个具体的车出来,并把具体引擎安上

Car car = newBus(engine2000);

car.installEngine();

Car car2= newBus(engine2200);

car2.installEngine();//想造什么类型的车并配上什么类型的引擎就直接new出来，不用产生那么多子类了。想做什么发动机就再做个

}

}

桥接模式：把所有模子都做出来，在构造器上进行安装具体哪种模子，此时构造器就相当于一个桥接介质， 把抽象和行为分开了。

减少了子类和代码量，比如当我想再增加一个Jeep车时，就不需要增加那么多子类文件(引擎)，而是安装一个总的Jeep车，再对引擎进行桥接。只需在main方法中这样写：

public classMainClass {public static voidmain(String[] args) {

Car jeepCar= newJeep(engine2000);

jeepCar.installEngine();

Car jeepCar2= newJeep(engine2200);

jeepCar2.installEngine();

}

}