定义:将抽象和实现解耦，使得两者之间可以独立的变化。

Abstract抽象化角色
---|主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用。该角色一般是抽象类
Implementor实现化角色
---|他是接口或者抽象类，定义角色必须的行为和属性
RefinedAbstraction修正抽象化角色
---|它引用实现化角色对抽象化角色进行修正
ConcreteImplementor具体实现化角色
---|它实现接口或抽象类定义的方法和属性
------抽象角色引用实现角色，或者说抽象角色的部分实现是引用实现角色来完成的。
桥梁模式使用了类间的聚合关系、继承、覆写等常用功能

public class BridgeTest {
	public static void main(String[] args) {
		//定义一个实现化角色
		Implementor imp = new ConcreteImplementor1();
		//定义一个抽象化角色
		Abstract abs = new RefinedAbstraction(imp);
		abs.request();
	}
}
/**
 * 实现化角色
 * 定义要实现的方法
 * @author admin
 *
 */
interface Implementor{
	//基本方法
	public void doSomething();
	public void doAnything();
}
/**
 * 具体实现化角色
 * @author admin
 */
class ConcreteImplementor1 implements Implementor{

	@Override
	public void doSomething() {
		System.out.println("具体实现化1，doSomething");
	}

	@Override
	public void doAnything() {
		System.out.println("具体实现化1，doAnything");
	}
}
/**
 * 具体实现化角色
 * @author admin
 */
class ConcreteImplementor2 implements Implementor{

	@Override
	public void doSomething() {
		System.out.println("具体实现化2，doSomething");
	}

	@Override
	public void doAnything() {
		System.out.println("具体实现化2，doAnything");
	}
	
}
/**
 * 抽象角色，定义该角色的行为，保存一个实现化角色的引用
 * @author admin
 *
 */
abstract class Abstract{
	//定义对实现化角色的引用
	private Implementor imp;
	//约束子类必须去实现该构造函数
	public Abstract(Implementor imp){
		this.imp = imp;
	}
	//自身的行为和属性
	public void request(){
		this.imp.doSomething();
	}
	//得到实现化角色
	public Implementor getImp(){
		return this.imp;
	}
}
/**
 * 具体抽象化角色
 * @author admin
 *
 */
class RefinedAbstraction extends Abstract{
	//覆写构造函数
	public RefinedAbstraction(Implementor imp) {
		super(imp);
	}
	//修正父类的行为
	@Override
	public void request() {
		super.request();
		super.getImp().doAnything();
	}
}

一个例子:

一个商人，开了两家公司，一家专门做正规的产品，另一家做能挣钱的（不管正不正规）产品。
因此，当市场上那些可以盈利，他都会立马转型去做这个东西。但是公司内部人员不会改变。
如何解决公司在不用改变内部结构的前提下，实现公司的转型呢?这就需要一个桥梁来连接。

public class BridgeT {
	public static void main(String[] args) {
		//创建产品对象
		House house = new House();
		//创建出公司对象
		Corp houseCorp = new HouseCorp(house);
		houseCorp.makeMoney();
	}
}
/**
 * 抽象的公司类，
 * 定义每个子公司需要实现的方法。
 * 同时保存对实现化类的引用
 * @author admin
 */
abstract class Corp{
	private Product product;
	//对实现化类的引用
	public Corp(Product product) {
		this.product = product;
	}
	//公司主要的目的是赚钱
	public void makeMoney(){
		//现生产商品
		this.product.beProducted();
		//再做销售
		this.product.beSell();
	}
}
/**
 * 具体的公司实现类，实现对实现化类的引用
 * @author admin
 *
 */
class HouseCorp extends Corp{

	public HouseCorp(Product product) {
		super(product);
	}
	@Override
	public void makeMoney() {
		//不该变公司的策略
		super.makeMoney();
		System.out.println("房地产公司赚大钱了。。。");
	}
}
/**
 * 抽象类，具体子公司要实现的方法
 * @author admin
 *
 */
abstract class Product{
	//产品销售
	public abstract void beSell();
	//产品生产
	public abstract void beProducted();
}
/**
 * 具体的产品实现类
 * @author admin
 */
class House extends Product{

	@Override
	public void beSell() {
		System.out.println("房子是这样卖出去的...");
	}
	@Override
	public void beProducted() {
		System.out.println("房子是这样生产的...");
	}
}

桥梁模式的优点:
---|抽象和实现分离
---|优秀的扩充能力
---|实现细节对客户透明。
桥梁模式的使用场景
---|不希望或不适用使用继承的场景
---|接口或抽象类不稳定的场景
---|重用性要求较高的场景