桥接模式

桥接模式：将某个问题抽象的不同形式分别与该问题的具体实现部分相分离，使他们都可以独立变化，并能够动态结合。

      例如电视厂商海尔，长虹生产21寸，29寸电视机。从这里要将它们分离出来，就用到桥接模式。电视机与电视机生产厂商挂桥，从而，分离出不同厂商的实现，与不同电视机型号的实现.

 

从上图可以看出，将实际抽象分离出来。

看下代码

//生产厂商TelevisionMaker作为Television的成员变量，它也是抽象类，但是它的具体

实现和Television的实现相分离,并且能和Television动态结合

//电视机抽象类

1. public abstract class Television {   
2.     //电视厂商   
3.     protected TelevisionMaker televisionMaker;   
4. 
   
5.     //收看电视   
6.     abstract public void teleview(TelevisionMaker televisionMaker);   
7. }  

 

//生产厂商抽象类

1. public abstract class TelevisionMaker {   
2.     abstract public void produce();   
3. }  

 

//电视机的型号，21英寸

1. public class Inch21 extends Television{   
2.        
3.     public void teleview(TelevisionMaker televisionMaker) {   
4.         System.out.println("21寸电视");   
5.     }   
6.   
7. }  

 

//电视机的型号，29英寸

1. public class Inch29 extends Television{   
2.        
3.     public void teleview(TelevisionMaker televisionMaker) {   
4.         System.out.println("29寸电视");   
5.     }   
6.   
7. }  

 

//电视机的具体生产厂商，长虹

public class ChangHong extends TelevisionMaker{   

1.   
2.     public ChangHong(){   
3.         System.out.println("长虹厂商");   
4.     }   
5.        
6.     public void produce() {   
7.         System.out.println("长虹厂商");   
8.     }   
9. }  

 

//电视机的具体生产厂商，海尔

1. public class Haier extends TelevisionMaker{   
2.     public Haier(){   
3.         System.out.println("海尔厂商");   
4.     }   
5.        
6.     public void produce() {   
7.         System.out.println("海尔厂商");   
8.     }   
9.   
10. }  

 

这样就使用了桥模式，将原本繁杂的系统分离开来。如果根据需求变动，要增加电视机生产型号或者电视机生产厂商，只需要实现相对应的抽象类即可。

这样，我们也可以根据用户的需要，得到他所需要的电视机，如长虹厂商出厂的29寸电视机。

测试代码如下：

1. public class Client {   
2.   
3.     public static void main(String[] args) {   
4.         // TODO Auto-generated method stub   
5.         Inch29 i = new Inch29();   
6.         i.teleview(new ChangHong());   
7.     }   
8. }  

 结果：

       长虹厂商
       29寸电视

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

结构如下图所示：

例子代码如下：

//定义一个事物的抽象，维护对行为实现（Implementor）的引用

//Shape抽象类
public abstract class Shape {
protected Drawing myDrawing;

abstract public void draw();

Shape(Drawing drawing) {
    myDrawing = drawing;
}

public void drawLine() {
   myDrawing.drawLine();
}

public void drawCircle() {
   myDrawing.drawCircle();
}
}

//Circle具体类

public class Circle extends Shape{
Circle(Drawing drawing) {
   super(drawing);
}

@Override
public void draw() {
   myDrawing.drawCircle();
}
}

//Rectangle 具体类

public class Rectangle extends Shape {
Rectangle(Drawing drawing) {
   super(drawing);
}

@Override
public void draw() {
   myDrawing.drawLine();
   myDrawing.drawLine();
   drawLine();
}
}

//实现部分的抽象，Drawing抽象类
public abstract class Drawing {
public abstract void drawLine();
public abstract void drawCircle();
}

//V1Drawing具体类

public class V1Drawing extends Drawing {
@Override
public void drawCircle() {
   DP1.draw_a_circle();
}

@Override
public void drawLine() {
   DP1.draw_a_line();
}
}

//V2Drawing具体类

public class V2Drawing extends Drawing{
@Override
public void drawCircle() {
   DP2.draw_a_circle();
}

@Override
public void drawLine() {
   DP2.draw_a_line();
}
}

public class DP1 {
public static void draw_a_line() {
   System.out.println("使用DP1的draw_a_line()画线");
}

public static void draw_a_circle() {
   System.out.println("使用DP1的draw_a_circle()画圆");
}
}

public class DP2 {
public static void draw_a_line() {
   System.out.println("使用DP2的draw_a_line()画线");
}

public static void draw_a_circle() {
   System.out.println("使用DP2的draw_a_circle()画圆");
}
}

//测试类
public class BridgeClient {
public static void main(String args[]) {
   Drawing draw1 = new V1Drawing();
   Drawing draw2 = new V2Drawing();

   Shape shape1 = new Rectangle(draw1);
   shape1.draw();

   Shape shape2 = new Circle(draw2);
   shape2.draw();

   Shape shape3 = new Circle(draw1);
   shape3.draw();
}
}

输出结果：
使用DP1的draw_a_line()画线
使用DP1的draw_a_line()画线
使用DP1的draw_a_line()画线
使用DP2的draw_a_circle()画圆
使用DP1的draw_a_circle()画圆

Bridge模式的优点：
1 分离接口及其实现部分。
2 提高可扩充性。
3 实现细节对客户透明。