桥梁模式简介

桥梁模式

定义：将抽象与实现解耦，是他们可以独立的变化。桥模式是继承关系的一种替代方式。


名词解释：
抽象 和 实现：
    这是设计模式中最难以理解的一种模式了，其实这是中文翻译的原因造成的，中文里 把派生类叫做抽象类的实现，而桥梁模式所讲的“实现”恰恰不是这个意思，桥梁模式中的“抽象”指的是抽象类及派生类，“实现”指的是这些抽象类及派生类实现自己的方式。


解耦：
    所谓耦合，就是两个实体的行为的某种强关联。而将它们的强关联去掉，就是耦合的解脱，或称解耦。在这里，解耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。
　 所谓强关联，就是在编译时期已经确定的，无法在运行时期动态改变的关联；所谓弱关联，就是可以动态地确定并且可以在运行时期动态地改变的关联。显然，在Java语言中，继承关系是强关联，而聚合关系是弱关联。
　 将两个角色之间的继承关系改为聚合关系，就是将它们之间的强关联改换成为弱关联。因此，桥梁模式中的所谓解耦，就是指在一个软件系统的抽象化和实现化之间使用聚合关系而不是继承关系，从而使两者可以相对独立地变化。这就是桥梁模式的用意。

我们拿一个具体的实例解释这一点：
    为汽车管理所 建立一个汽车管理的模型，要求对各个汽车制造厂生产的各种汽车进行管理。
假设我们这样设计，首先设计一个抽象的汽车类Car.java，然后不同的汽车如货车、公共汽车继承这个抽象的汽车类。
Car.java：

public interface Car{
	void produce(){
	}
} 

Truck.java

public class Truck extends Car {
    public void produce() {
    }
}

Bus.java

public class Bus extends Car {
    public void produce() {
    }
}

汽车可以被多个汽车制造商制造，比如一汽、二汽等，我们这样设计：
一汽生产的货车类FawTruck.java

public class FawTruck extends Truck{
	 public void produce() {
    }
}

一汽生产的公共汽车类FawBus.java

public class FawBus extends Truck{
	 public void produce() {
    }
}

二汽生产的货车类DfmcTruck.java

public class DfmcTruck extends Truck{
	 public void produce() {
    }
}

二汽生产的公共汽车类FawBus.java

public class DfmcBus extends Truck{
	 public void produce() {
    }
}

    这样问题出现了，假设我们有15中车型，6家汽车制造商，那么我们不得不实现15×6 = 90 种子类车型，这样设计势必造成类的数量翻倍的上升，工作量巨大。
    造成这种现象的原因在于我们把汽车的抽象和它的实现耦合在一起了，如果能将车型和制造商的分离开，问题就可以解决。


我们利用桥梁模式实现：

Car.java
public abstract class Car {
    public Car(Manufacturer lnkManufacturer) {
        this.lnkManufacturer = lnkManufacturer;
    }

Car.java

public abstract class Car {
    public Car(Manufacturer lnkManufacturer) {
        this.lnkManufacturer = lnkManufacturer;
    }

   public void produce() {
		lnkManufacturer.produce();
   }

    /**
     * @directed 
     */
    Manufacturer lnkManufacturer;
}

制造商类Manufacturer.java

public interface Manufacturer {
    void produce();
}

Truck.java

public class Truck extends Car {
    public Truck(Manufacturer lnkManufacturer) {
        super(lnkManufacturer);
    }


    public void produce() {
        lnkManufacturer.produce();
        System.out.println("的货车");
    }
}

Bus.java

public class Bus extends Car {
     public Bus(Manufacturer lnkManufacturer) {
        super(lnkManufacturer);
    }
    public void produce() {
		lnkManufacturer.produce();
        System.out.println("的公共汽车");
    }
}

一汽Faw.java

public class Faw implements Manufacturer {
    public void produce() {
        System.out.println("一汽制造");
    }
}

二汽Dfmc.java

public class Dfmc implements Manufacturer {
    public void produce() {
        System.out.println("二汽制造");
    }
}

    这样如果新的车型进来，就继承Car.java，如果有新的制造商进来，就实现Manufacturer.java,除此之外不需要添加任何代码。如果客户要求，采用一汽 生产的 货车，则在客户端调用的代码如下：

public class Client {
    public static void main(String[] argv) {
        Car car = new Truck(new Faw());
        car.produce();
    }
}

    同理，如果车型和制造商有变时，则只需要更改客户端相应的Car的子类和Manufacturer的子类即可。

    桥梁模式由4部分组成：抽象类、抽象类的继承类、实现类、实现类的继承类。桥梁模式的原理图如下：

代码如下：

抽象化角色类，它声明了一个方法operation()，并给出了它的实现。这个实现是通过向实现化对象的委派(调用operationImpl()方法)实现的。

public abstract class Abstraction {
    protected Implementor impl;
    public Abstraction(Implementor impl){
        this.impl = impl;
    }
    //示例方法
    public void operation(){      
        impl.operationImpl();
    }
}

抽象类的实现类：

public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor impl) {
        super(impl);
    }
    //其他的操作方法
    public void otherOperation(){
 
    }
}

实现类：

public abstract class Implementor {
    /**
     * 示例方法，实现抽象部分需要的某些具体功能
     */
    public abstract void operationImpl();
}

实现类的继承类：

public class ConcreteImplementorA extends Implementor {
    @Override
    public void operationImpl() {
        //具体操作
    }
}
public class ConcreteImplementorB extends Implementor {
    @Override
    public void operationImpl() {
        //具体操作
    }
}　

    桥梁模式的使用时机：当系统需要在他的抽象和实现之间增加更多的灵活性，或者一个对象有多于一个抽象和是实现时，就需要使用桥梁模式。