首页 > 代码库 > 24种设计模式--桥梁模式【Bridge Pattern】
24种设计模式--桥梁模式【Bridge Pattern】
今天我要说说我自己，梦想中的我自己，我身价过亿，有两个大公司，一个是房地产公司，一个是服装制造业，这两个公司都很赚钱，天天帮我在累加财富，其实是什么公司我倒是不关心，我关心的是是不是在赚钱，赚了多少，我先用类图表示一下我这两个公司：
类图很简单，声明了一个 Corp 抽象类，定义一个公司的抽象模型，公司首先要是赚钱的，不赚钱谁开公司，做义务或善举那也是有背后利益支撑的，我还是赞这句话“天下熙熙，皆为利来；天下壤壤，皆为利往”，那我们先看 Corp 类的源代码：
1 package com.pattern.bridge; 2 3 /** 4 * 定义一个公司的抽象类 5 * @author http://www.cnblogs.com/initial-road/ 6 * 7 */ 8 public abstract class Corp { 9 10 /**11 * 是公司就应该有生产吧，甭管是什么软件公司还是制造业公司12 * 那每个公司生产的东西都不一样，所以由实现类来完成13 */14 protected abstract void produce();15 16 /**17 * 有产品了，那肯定要销售呀，不销售你公司怎么生存18 */19 protected abstract void sell();20 21 /**22 * 公司是干什么的？赚钱的23 */24 protected void makeMoney(){25 26 //每个公司都是一样，先生产27 this.produce();28 29 //然后销售30 this.sell();31 32 }33 34 }合适的方法存在合适的类中，这个基本上是每本 Java 基础书上都会讲的，但是到实际的项目中应用的时候就不是这么回事儿了，正常的很。我们继续看两个实现类如何实现的，先看 HouseCorp 类，这个是我最赚钱的公司：
1 package com.pattern.bridge; 2 3 /** 4 * 房地产公司，按照翻译来说应该叫realty corp，这个是比较准确的翻译 5 * 但是我问你房地产公司翻译成英文，你第一反应是什么？对嘛还是house corp 6 * @author http://www.cnblogs.com/initial-road/ 7 * 8 */ 9 public class HouseCorp extends Corp {10 11 // 房地产公司就是盖房子12 protected void produce() {13 System.out.println("房地产公司盖房子...");14 }15 16 // 房地产卖房子，自己住那可不赚钱17 protected void sell() {18 System.out.println("房地产公司出售房子...");19 }20 21 // 房地产公司很High了，赚钱，计算利润22 public void makeMoney(){23 super.makeMoney();24 System.out.println("房地产公司赚大钱了...");25 }26 27 }28 29 然后看服装公司，虽然不景气，但好歹也是赚钱的：30 31 package com.pattern.bridge;32 33 /**34 * 服装公司，这个行当现在不怎么样35 * @author http://www.cnblogs.com/initial-road/36 *37 */38 public class ClothesCorp extends Corp {39 40 // 服装公司生成的就是衣服了41 protected void produce() {42 System.out.println("服装公司生产衣服...");43 }44 45 // 服装公司做服装，可只卖服装，不买穿衣服的模特46 protected void sell() {47 System.out.println("服装公司出售衣服...");48 }49 50 // 服装公司不景气，但怎么说也是赚钱行业耶51 public void makeMoney(){52 super.makeMoney();53 System.out.println("服装公司赚小钱...");54 }55 56 }两个公司都有了，那肯定有人会关心两个公司的运营情况呀，我自己怎么也要知道它是生产什么的，赚多少钱吧，那看看这个 Client.java 是什么样子的：
1 package com.pattern.bridge; 2 3 /** 4 * 我要关心我自己的公司了 5 * @author http://www.cnblogs.com/initial-road/ 6 * 7 */ 8 public class Client { 9 10 public static void main2(String[] args) {11 System.out.println("------房地产公司是这个样子运行的------");12 // 先找到我的公司13 HouseCorp houseCorp = new HouseCorp();14 // 看我怎么挣钱15 houseCorp.makeMoney();16 System.out.println("\n");17 18 System.out.println("------服装公司是这样运行的------");19 ClothesCorp clothesCorp = new ClothesCorp();20 clothesCorp.makeMoney();21 }22 23 }上述代码完全可以描述我现在的公司，但是你要知道万物都是运动的，你要用运动的眼光看问题，我公司也会发展，终于在有一天我觉得赚钱速度太慢，于是我上下疏通，左右打关系，终于开辟了一条赚钱的康庄大道：生产山寨产品，什么产品呢？就是市场上什么牌子的东西火爆我生产什么牌子的东西，甭管是打火机还是电脑，只要它火爆，我就生产，赚过了高峰期就换个产品，打一枪换一个牌子，不承担售后成本、也不担心销路问题，我只有正品的十分之一的价格，你买不买？哈哈，赚钱呀！
企业的方向定下来了，通过调查，市场上前段时间比较火爆的是苹果 iPod，那咱就生产这个，把服装厂该成 iPod 生产厂，看类图的变化：
好，我的企业改头换面了，开始生产 iPod 产品了，看我 IPodCorp 类的实现：
1 package com.pattern.bridge; 2 3 /** 4 * 我是山寨老大，你流行啥我生产啥 5 * 现在流行ipod 6 * @author http://www.cnblogs.com/initial-road/ 7 * 8 */ 9 public class IPodCorp extends Corp {10 11 // 我开始生产iPod了12 protected void produce() {13 System.out.println("我生产iPod...");14 }15 16 // 山寨的iPod很畅销，便宜呀17 protected void sell() {18 System.out.println("iPod畅销...");19 }20 21 public void makeMoney(){22 super.makeMoney();23 System.out.println("我赚钱呀...");24 }25 26 }27 28 这个厂子修改完毕了，我这个董事长还要去看看到底生产什么的，看这个 Client.java 程序：29 30 package com.pattern.bridge;31 32 /**33 * 我要关心我自己的公司了34 * @author http://www.cnblogs.com/initial-road/35 *36 */37 public class Client {38 39 public static void main2(String[] args) {40 System.out.println("------房地产公司是这个样子运行的------");41 // 先找到我的公司42 HouseCorp houseCorp = new HouseCorp();43 // 看我怎么挣钱44 houseCorp.makeMoney();45 System.out.println("\n");46 47 System.out.println("------山寨公司是这样运行的------");48 IPodCorp iPodCorp = new IPodCorp();49 iPodCorp.makeMoney();50 }51 52 }确实，只用修改了几句话，我的服装厂就开始变成山寨 iPod 生产车间，然后就看我的财富在积累，你想呀山寨的东西不需要特别的销售渠道，不需要维修成本，不承担广告成本，但是我也有犯愁的时候，我这是个山寨工厂，要及时的生产出市场上流行产品，转型要快，要灵活，今天从生产 iPod转为生产MP4, 明天再转为生产上网本，这个都需要灵活的变化，不要限制的太死，那问题来了，每次我的厂房，我的工人，我的设备都在，不可能每次我换个山寨产品我的厂子就彻底不要了，这不行，成本忒高了点，那怎么办？
这样设计：
Corp 类和 Product 类建立一个关联关系，可以彻底解决我以后山寨公司生产产品的问题，看程序说话，先看 Product 抽象类：
1 package com.pattern.bridge.implementor; 2 3 /** 4 * 这是我整个集团公司的产品类 5 * @author http://www.cnblogs.com/initial-road/ 6 * 7 */ 8 public abstract class Product { 9 10 //甭管是什么产品它总要是能被生产出来11 public abstract void beProducted();12 13 // 生产出来的东西，一定要销售出去，否则亏本呀14 public abstract void beSelled();15 16 }17 18 简单，忒简单了，看 House 产品类：19 20 package com.pattern.bridge.implementor;21 22 23 /**24 * 这是我集团公司盖的房子25 * @author http://www.cnblogs.com/initial-road/26 *27 */28 public class House extends Product {29 30 // 豆腐渣就豆腐渣呗，好歹也是个房子31 public void beProducted() {32 System.out.println("生产出的房子是这个样子的...");33 }34 35 // 虽然是豆腐渣，也是能够销售出去的36 public void beSelled() {37 System.out.println("生产出的房子卖出去了...");38 }39 40 }41 42 不多说，看 Clothes 产品类：43 44 package com.pattern.bridge.implementor;45 46 /**47 * 我集团公司生产的衣服48 * @author http://www.cnblogs.com/initial-road/49 *50 */51 public class Clothes extends Product {52 53 public void beProducted() {54 System.out.println("生产出的衣服是这个样子的...");55 }56 57 public void beSelled() {58 System.out.println("生产出的衣服卖出去了...");59 }60 61 }62 63 下面是 iPod 产品类：64 65 package com.pattern.bridge.implementor;66 67 /**68 * 生产iPod了69 * @author http://www.cnblogs.com/initial-road/70 *71 */72 public class IPod extends Product {73 74 public void beProducted() {75 System.out.println("生产出的iPod是这个样子的...");76 }77 78 public void beSelled() {79 System.out.println("生产出的iPod卖出去了...");80 }81 82 }产品类是有了，那我们再看 Corp 抽象类：
1 package com.pattern.bridge.abstraction; 2 3 import com.pattern.bridge.implementor.Product; 4 5 /** 6 * 定义一个公司的抽象类 7 * @author http://www.cnblogs.com/initial-road/ 8 * 9 */10 public abstract class Corp {11 12 // 定义一个产品对象， 抽象的了，不知道具体是什么产品13 private Product product;14 15 // 构造函数，由子类定义传递具体的产品进来16 public Corp(Product product){17 this.product = product;18 }19 20 // 公司是干什么的？赚钱的呀21 public void makeMoney(){22 23 // 每个公司都是一样，先生产24 this.product.beProducted();25 26 // 然后销售27 this.product.beSelled();28 29 }30 31 }这里多了个有参构造，其目的是要继承的子类都必选重写自己的有参构造函数，把产品类传递进来，再看子类 HouseCorp 的实现：
1 package com.pattern.bridge.abstraction; 2 3 import com.pattern.bridge.implementor.House; 4 5 /** 6 * 房地产公司，按照翻译来说应该叫realty corp，这个是比较准确的翻译 7 * 但是我问你房地产公司翻译成英文，你第一反应什么？对吗还是house corp! 8 * @author http://www.cnblogs.com/initial-road/ 9 *10 */11 public class HouseCorp extends Corp {12 13 // 定义传递一个House产品进来14 public HouseCorp(House house) {15 super(house);16 }17 18 // 房地产公司很High了，赚钱，计算利润19 protected void produce() {20 super.makeMoney();21 System.out.println("房地产公司赚大钱了...");22 }23 24 protected void sell() {25 System.out.println("销售房子了...");26 }27 28 }29 30 理解上没有多少难度，不多说，继续看山寨公司的实现:31 32 package com.pattern.bridge.abstraction;33 34 import com.pattern.bridge.implementor.Product;35 36 /**37 * 我是山寨老大，你流行啥我就生产啥38 * @author http://www.cnblogs.com/initial-road/39 *40 */41 public class ShanZhaiCorp extends Corp {42 43 // 产什么产品，不知道，等被调用了才知道44 public ShanZhaiCorp(Product product) {45 super(product);46 }47 48 // 狂赚钱49 public void makeMoney(){50 super.makeMoney();51 System.out.println("我赚钱呀...");52 }53 }HouseCorp 类和 ShanZhaiCorp 类的区别是在有参构造的参数类型上， HouseCorp 类比较明确，我就是只要 House 类，所以直接定义传递进来的必须是 House 类， 一个类尽可能少的承担职责，那方法也是一样，既然 HouseCorp 类已经非常明确只生产 House 产品，那为什么不定义成 House 类型呢？ShanZhaiCorp 就不同了，它是确定不了生产什么类型。
好了，两大对应的阵营都已经产生了，那我们再看 Client 程序：
1 package com.pattern.bridge.abstraction; 2 3 import com.pattern.bridge.implementor.House; 4 import com.pattern.bridge.implementor.IPod; 5 6 /** 7 * 我要关心我自己的公司了 8 * @author http://www.cnblogs.com/initial-road/ 9 *10 */11 public class Client {12 13 public static void main(String[] args) {14 House house = new House();15 System.out.println("-----房地产公司是这个样子运行的-----");16 // 先找到我的公司17 HouseCorp houseCorp = new HouseCorp(house);18 // 看我怎么挣钱19 houseCorp.makeMoney();20 System.out.println("\n");21 22 // 山寨公司生产的产品很多，不过我只要制定的产品就成了23 System.out.println("-----山寨公司是这样子运行的-----");24 ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new IPod());25 shanZhaiCorp.makeMoney();26 }27 28 }29 30 这个山寨公司的前身是生产衣服的，那我现在要修改一下，生产 iPod，看如下的变化：31 32 package com.pattern.bridge.abstraction;33 34 import com.pattern.bridge.implementor.House;35 import com.pattern.bridge.implementor.IPod;36 37 /**38 * 我要关心我自己的公司了39 * @author http://www.cnblogs.com/initial-road/40 *41 */42 public class Client {43 44 public static void main(String[] args) {45 House house = new House();46 System.out.println("-----房地产公司是这个样子运行的-----");47 // 先找到我的公司48 HouseCorp houseCorp = new HouseCorp(house);49 // 看我怎么挣钱50 houseCorp.makeMoney();51 System.out.println("\n");52 53 // 山寨公司生产的产品很多，不过我只要制定的产品就成了54 System.out.println("-----山寨公司是这样子运行的-----");55 // ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new Clothes());56 ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new IPod());57 shanZhaiCorp.makeMoney();58 }59 60 }看代码上注释的一行代码，就修改了这一句代码就完成了生产产品的转换。那我们深入的思考一下，既然万物都是运动的，我现在只有房地产公司和山寨公司，那以后我会不会增加一些其他的公司呢？或者房地产公司会不会对业务进行细化，比如分为公寓房公司，别墅公司，以及商业房公司等等呢？那我告诉你，会的，绝对的会的，但是你发觉没，这种变化对我们上面的类图没有大的修改，充其量是扩展，你看呀：
增加公司，你要么继承 Corp 类，要么继承 HouseCorp 或 ShanZhaiCorp，不用再修改原有的类了；增加产品，继承 Product 类，或者继承 House类，你要把房子分为公寓住房、别墅、商业用房等等；你都是在扩展，唯一你要修改的就是 Client 类，你类都增加了哪能不修改调用呢，也就是说 Corp 类和 Product 类都可以自由的扩展，而不会对整个用产生太的变更，这就是桥梁模式。
为什么叫桥梁模式？我们看一下桥梁模式的通用类图：
看到中间那根带箭头的线了吗？是不是类似一个桥，连接了两个类？所以就叫桥梁模式。我们再把桥梁模式的几个概念熟悉一下，大家有没有注意到我把 Corp 类以及它的两个实现类放到了 Abstraction 包中，把 House以及相关的三个实现类放到了 Implementor 包中，这两个包分别对应了桥梁模式的业务抽象角（Abstraction）和业务实现角色（Implementor），这两个角色我估计没几个人能说的明白，特别是看了“四人帮”的书或者是那本非常有名的、比砖头还要厚的书，你会越看越糊涂，忒专业化，有点像看政府的红头文件，什么都说了，可好像又什么都没有说。这两个角色大家只要记住一句话就成：业务抽象角色引用业务实现角色，或者说业务抽象角色的部分实现是由业务实现角色完成的，很简单，别想那么复杂了。
桥梁模式的优点就是类间解耦，我们上面已经提到，两个角色都可以自己的扩展下去，不会相互影响，这个也符合 OCP 原则。
今天说到桥梁模式，那就多扯几句，大家对类的继承有什么看法吗？继承的优点有很多，可以把公共的方法或属性抽取，父类封装共性，子类实现特性，这是继承的基本功能，缺点有没有？有，强关联关系，父类有个方法，你子类也必须有这个方法，是不可选择的，那这会带来扩展性的问题，我举个简单的例子来说明这个问题：Father 类有一个方法A， Son 继承了这个方法，然后GrandSon 也继承了这个方法，问题是突然有一天Son要重写父类的这个方法，他敢做吗？绝对不敢！ GrandSon 可是要用从Father 继承过来的方法A，你修改了，那就要修改Son 和GrandSon 之间的关系，那这个风险就大了去。
今天讲的这个桥梁模式就是这一问题的解决方法，桥梁模式描述了类间弱关联关系，还说上面的那个例子，Fater 类完全可以把可能会变化的方法放出去， Son 子类要有这个方法很简单，桥梁搭过去，获得这个方法，GrandSon 也一样，即使你Son 子类不想使用这个方法了，也没关系，对GrandSon 不产生影响，他不是从你Son 中继承来的方法！
继承不能说它不好，非常好，但是有缺点的，我们可以扬长避短，对于比较明确不发生变化的，则通过继承来完成，若不能确定是否会发生变化的，那就认为是会发生变化，则通过桥梁模式来解决，这才是一个完美的世界。
24种设计模式--桥梁模式【Bridge Pattern】