JAVA设计模式(十三)——桥接模式

1、桥接模式

        Bridge模式又叫做桥接模式，是构造型的设计模式之一。Bridge模式基于类的最小设计原则，通过使用封装，聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽象（abstraction）与行为实现（implementation）分离开来，从而可以保持各部分的独立性以及应对它们的功能扩展。

        桥接模式的用意是"将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化"。

2、问题提出

        在提出桥接模式之前，我们先看看，在这之前，我们会如何设计代码，如下：

一个接口：

public interface TestCar {
	
	public void installEngine();
	
	public void installEngine2000();
	
	public void installEngine4000();
}

一个实现类：

public class TestBus implements TestCar {

	@Override
	public void installEngine() {
		// TODO Auto-generated method stub
		System.out.println("安装引擎");
	}

	@Override
	public void installEngine2000() {
		// TODO Auto-generated method stub
		System.out.println("安装引擎2000");
	}

	@Override
	public void installEngine4000() {
		// TODO Auto-generated method stub
		System.out.println("安装引擎4000");
	}

}

这里会出现一个问题，当我们需要新的引擎的时候，会发现需要再改动我们的接口类，同时，我们的实现类对象也会要实现太多的类，怎么办？使用桥接模式！

3、结构图

还是老规矩，我们看看桥接模式的结构图示：

4、角色与职责

从上面的结构图来看，主要有以下几种结构图示，如下：
1）抽象化(Abstraction)角色：抽象化给出的定义，并保存一个对实现化对象的引用。

2）修正抽象化(Refined Abstraction)角色：扩展抽象化角色，改变和修正父类对抽象化的定义。

3）实现化(Implementor)角色：这个角色给出实现化角色的接口，但不给出具体的实现。必须指出的是，这个接口不一定和抽象化角色的接口定义相同，实际上，这两个接口可以非常不一样。实现化角色应当只给出底层操作，而抽象化角色应当只给出基于底层操作的更高一层的操作。

4）具体实现化(Concrete Implementor)角色：这个角色给出实现化角色接口的具体实现。

5、桥接示例

引擎的接口以及两个实现类：

public interface Engine {  
  
    /** 
     * 安装发动引擎 
     */  
    public void installEngine();  
}

public class Engine2000 implements Engine {  
	  
    @Override  
    public void installEngine() {  
        System.out.println("安装2000CC发动引擎");  
    }  
  
}

public class Engine2200 implements Engine {  
	  
    @Override  
    public void installEngine() {  
        System.out.println("安装2200CC发动引擎");  
    }  
  
}

抽象类对象：

public abstract class Car {  
  
    private Engine engine;  
      
    public Car(Engine engine) {  
        this.engine = engine;  
    }  
  
    public Engine getEngine() {  
        return engine;  
    }  
  
    public void setEngine(Engine engine) {  
        this.engine = engine;  
    }  
      
    public abstract void installEngine();  
}

两个不同的实现类：

public class Bus extends Car {  
  
    public Bus(Engine engine) {  
        super(engine);  
    }  
      
    @Override  
    public void installEngine() {  
        System.out.print("Bus:");  
        this.getEngine().installEngine();  
    }  
  
}

public class Jeep extends Car {  
  
    public Jeep(Engine engine) {  
        super(engine);  
    }  
    @Override  
    public void installEngine() {  
        System.out.print("Jeep:");  
        this.getEngine().installEngine();  
    }  
  
}

6、测试与总结

测试代码：

/**
 * 主测试方法
 * @author ljtyzhr
 *
 */
public class MainClass {  
	
	/**
	 * 测试
	 * @param args
	 */
    public static void main(String[] args) {
    	
    	TestCar test = new TestBus();
    	test.installEngine();
    	
    	
        Engine engine2000 = new Engine2000();  
        Engine engine2200 = new Engine2200();  
          
        Car bus = new Bus(engine2000);  
        bus.installEngine();  
          
        Car jeep = new Jeep(engine2200);  
        jeep.installEngine();  
    }  
} 

总结

        在测试中，我们可以看到，如果我们开发出来新的引擎，只需要将这个引擎实现刚才的Engine这个接口就行了。而我们的实例类呢，比如bus和jeep，他们仅仅需要一个对该新的引擎的一个引用就行了，这样就实现了解耦合。