**定义**:将抽象和实现解耦，使得两者之间可以独立的变化。  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("房子是这样生产的..."); } } ~~~ **桥梁模式的优点:** ---|抽象和实现分离 ---|优秀的扩充能力 ---|实现细节对客户透明。 **桥梁模式的使用场景** ---|不希望或不适用使用继承的场景 ---|接口或抽象类不稳定的场景 ---|重用性要求较高的场景