桥梁模式【 Bridge Pattern】

  博客地址  http://blog.csdn.net/ftx2540993425

  下面横线以上内容是借鉴别人的，为了表达对作者的敬意，不做不恰当的修改，我个人的总结在后面。好的东西

今天我要说说我自己，梦想中的我自己，我身价过亿，有两个大公司，一个是房地产公司，一个是服装制造
业，这两个公司都很赚钱，天天帮我在累加财富，其实是什么公司我倒是不关心，我关心的是是不是在赚钱，赚
了多少，这才是我关心的，我是商人呀，唯利是图是我的本性，偷税漏税是我的方法，欺上瞒下、压榨员工血汗
我是的手段嘛，我先用类图表示一下我这两个公司：

类图很简单，声明了一个 Corp 抽象类，定义一个公司的抽象模型，公司首要是赚钱的，不赚钱谁开公司，
做义务或善举那也是有背后利益支撑的，我还是赞成这句话“天下熙熙，皆为利来；天下壤壤，皆为利往”，那
我们先看 Corp 类的源代码：

<span style="font-size:14px;">package com.cbf4life;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 定义一个公司的抽象类*/public abstract class Corp {/** 是公司就应该有生产把，甭管是什么软件公司还是制造业公司* 那每个公司的生产的东西都不一样，所以由实现类来完成*/protected abstract void produce();/** 有产品了，那肯定要销售呀，不销售你公司怎么生存*/protected abstract void sell();//公司是干什么的？赚钱的呀，不赚钱傻子才干public void makeMoney(){//每个公司都是一样，先生产this.produce();//然后销售this.sell();}}</span>

合适的方法存在合适的类中，这个基本上是每本 Java 基础书上都会讲的，但是到实际的项目中应用的时候
就不是这么回事儿了，正常的很。我们继续看两个实现类如何实现的，先看 HouseCorp 类，这个是我最赚钱的
公司：

package com.cbf4life;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 房地产公司，按照翻译来说应该叫realty corp，这个是比较准确的翻译* 但是我问你房地产公司翻译成英文，你第一反应什么？对嘛还是house corp!*/public class HouseCorp extends Corp {//房地产公司就是盖房子protected void produce() {System.out.println("房地产公司盖房子...");}//房地产卖房子，自己住那可不赚钱protected void sell() {System.out.println("房地产公司出售房子...");}//房地产公司很High了，赚钱，计算利润public void makeMoney(){super.makeMoney();System.out.println("房地产公司赚大钱了...");}}

然后看服装公司，虽然不景气，但好歹也是赚钱的：

package com.cbf4life;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 服装公司，这个行当现在不怎么样*/public class ClothesCorp extends Corp {//服装公司生产的就是衣服了protected void produce() {System.out.println("服装公司生产衣服...");}//服装公司买服装，可只卖服装，不买穿衣服的模特protected void sell() {System.out.println("服装公司出售衣服...");}//服装公司不景气，但怎么说也是赚钱行业也public void makeMoney(){super.makeMoney();System.out.println("服装公司赚小钱...");}}

两个公司都有了，那肯定有人会关心两个公司的运营情况呀，我自己怎么也要知道它是生产什么的，赚多少
钱吧，那看看这个 Client.java 是什么样子的：

package com.cbf4life;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我要关心我自己的公司了*/public class Client {public static void main(String[] args) {System.out.println("-------房地产公司是这个样子运行的-------");//先找到我的公司HouseCorp houseCorp =new HouseCorp();//看我怎么挣钱houseCorp.makeMoney();System.out.println("\n");System.out.println("-------服装公司是这样运行的-------");ClothesCorp clothesCorp = new ClothesCorp();clothesCorp.makeMoney();}}

看，这个代码很简单，运行结果如下：
-------房地产公司是这个样子运行的-------
房地产公司盖房子...
房地产公司出售房子...
房地产公司赚大钱了...
-------服装公司是这样运行的-------
服装公司生产衣服...
服装公司出售衣服...
服装公司赚小钱...

上述代码完全可以描述我现在的公司，但是你要知道万物都是运动的，你要用运动的眼光看问题，我公司也

会发展，终于在有一天我觉得赚钱速度太慢，于是我上下疏通，左右打关系，终于开辟了一条赚钱的康庄大道：
生产山寨产品，什么产品呢？就是市场上什么牌子的东西火爆我生产什么牌子的东西，甭管是打火机还是电脑，
只要它火爆，我就生产，赚过了高峰期就换个产品，打一枪换一个牌子，不承担售后成本、也不担心销路问题，
我只有正品的十分之一的价格，你买不买？哈哈，赚钱呀！
企业的方向定下来了，通过调查，市场上前段时间比较火爆的是苹果 iPod，那咱就生产这个，把服装厂该
成 iPod 生产厂，看类图的变化：

好，我的企业改头换面了，开始生产 iPod 产品了，看我 IPodCorp 类的实现

package com.cbf4life;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我是山寨老大，你流行啥我就生产啥* 现在流行iPod*/public class IPodCorp extends Corp {//我开始生产iPod了protected void produce() {System.out.println("我生产iPod...");}//山寨的iPod很畅销，便宜呀protected void sell() {System.out.println("iPod畅销...");}//狂赚钱public void makeMoney(){super.makeMoney();System.out.println("我赚钱呀...");}}

这个厂子修改完毕了，我这个董事长还要去看看到底生产什么的，看这个 Client.java 程序：

package com.cbf4life;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我要关心我自己的公司了*/public class Client {public static void main(String[] args) {System.out.println("-------房地产公司是这个样子运行的-------");//先找到我的公司HouseCorp houseCorp =new HouseCorp();//看我怎么挣钱houseCorp.makeMoney();System.out.println("\n");System.out.println("-------山寨公司是这样运行的-------");IPodCorp iPodCorp = new IPodCorp();iPodCorp.makeMoney();}}

确实，只用修改了几句话，我的服装厂就开始变成山寨 iPod 生产车间，然后就看我的财富在积累积累，你
想呀山寨的东西不需要特别的销售渠道（正品到哪里我就到哪里），不需要维修成本（大不了给你换个，你还想
咋地，过了高峰期我就改头换面了你找谁维修去，投诉？投诉谁呢？），不承担广告成本（正品在打广告，我还
需要吗？需要吗？），但是我也有犯愁的时候，我这是个山寨工厂，要及时的生产出市场上流行产品，转型要快，
要灵活，今天从生产 iPod 转为生产 MP4,明天再转为生产上网本，这个都需要灵活的变化，不要限制的太死，
那问题来了，每次我的厂房，我的工人，我的设备都在，不可能每次我换个山寨产品我的厂子就彻底不要了，这
不行，成本忒高了点，那怎么办？
Thinking，Thinking….，I got an idea!，这样设计：

Corp 类和 Product 类建立一个关联关系，可以彻底解决我以后山寨公司生产产品的问题，看程序说话，
先看 Product 抽象类：

public abstract class Product {//甭管是什么产品它总要是能被生产出来public abstract void beProducted();//生产出来的东西，一定要销售出去，否则扩本呀public abstract void beSelled();}

简单，忒简单了，看 House 产品类：

package com.cbf4life.implementor;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 这是我集团公司盖的房子*/public class House extends Product {//豆腐渣就豆腐渣呗，好歹也是个房子public void beProducted() {System.out.println("生产出的房子是这个样子的...");}//虽然是豆腐渣，也是能够销售出去的public void beSelled() {System.out.println("生产出的房子卖出去了...");}}

不多说，看 Clothes 产品类：

package com.cbf4life.implementor;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我集团公司生产的衣服*/public class Clothes extends Product {public void beProducted() {System.out.println("生产出的衣服是这个样子的...");}public void beSelled() {System.out.println("生产出的衣服卖出去了...");}}

下面是 iPod 产品类：

package com.cbf4life.implementor;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 生产iPod了*/public class IPod extends Product {public void beProducted() {System.out.println("生产出的iPod是这个样子的...");}public void beSelled() {System.out.println("生产出的iPod卖出去了...");}}

产品类是有了，那我们再看 Corp 抽象类：

package com.cbf4life.abstraction;import com.cbf4life.implementor.Product;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 定义一个公司的抽象类*/public abstract class Corp {//定义一个产品对象，抽象的了，不知道具体是什么产品private Product product;//构造函数，由子类定义传递具体的产品进来public Corp(Product product){this.product = product;}//公司是干什么的？赚钱的呀，不赚钱傻子才干public void makeMoney(){//每个公司都是一样，先生产this.product.beProducted();//然后销售this.product.beSelled();}}

这里多了个有参构造，其目的是要继承的子类都必选重写自己的有参构造函数，把产品类传递进来，再看子
类 HouseCorp 的实现：

package com.cbf4life.abstraction;import com.cbf4life.implementor.House;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 房地产公司，按照翻译来说应该叫realty corp，这个是比较准确的翻译* 但是我问你房地产公司翻译成英文，你第一反应什么？对嘛还是house corp!*/public class HouseCorp extends Corp {//定义传递一个House产品进来public HouseCorp(House house){super(house);}//房地产公司很High了，赚钱，计算利润public void makeMoney(){super.makeMoney();System.out.println("房地产公司赚大钱了...");}}

理解上没有多少难度，不多说，继续看山寨公司的实现:

package com.cbf4life.abstraction;import com.cbf4life.implementor.Product;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我是山寨老大，你流行啥我就生产啥*/public class ShanZhaiCorp extends Corp {//产什么产品，不知道，等被调用的才知道public ShanZhaiCorp(Product product){super(product);}//狂赚钱public void makeMoney(){super.makeMoney();System.out.println("我赚钱呀...");}}

HouseCorp 类和 ShanZhaiCorp 类的区别是在有参构造的参数类型上，HouseCorp 类比较明确，我就是
只要 House 类，所以直接定义传递进来的必须是 House 类， 一个类尽可能少的承担职责，那方法也是一样，
既然 HouseCorp 类已经非常明确只生产 House 产品，那为什么不定义成 House 类型呢？ShanZhaiCorp 就
不同了，它是确定不了生产什么类型。

好了，两大对应的阵营都已经产生了，那我们再看 Client 程序：

package com.cbf4life;import com.cbf4life.abstraction.HouseCorp;import com.cbf4life.abstraction.ShanZhaiCorp;import com.cbf4life.implementor.Clothes;import com.cbf4life.implementor.House;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我要关心我自己的公司了*/public class Client {public static void main(String[] args) {House house = new House();System.out.println("-------房地产公司是这个样子运行的-------");//先找到我的公司HouseCorp houseCorp =new HouseCorp(house);//看我怎么挣钱houseCorp.makeMoney();System.out.println("\n");//山寨公司生产的产品很多，不过我只要指定产品就成了System.out.println("-------山寨公司是这样运行的-------");ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new Clothes());shanZhaiCorp.makeMoney();}}

运行结果如下：
-------房地产公司是这个样子运行的-------
生产出的房子是这个样子的...
生产出的房子卖出去了...
房地产公司赚大钱了...
-------山寨公司是这样运行的-------
生产出的衣服是这个样子的...
生产出的衣服卖出去了...
我赚钱呀...

这个山寨公司的前身是生产衣服的，那我现在要修改一下，生产 iPod，看如下的变化：

package com.cbf4life;import com.cbf4life.abstraction.HouseCorp;import com.cbf4life.abstraction.ShanZhaiCorp;import com.cbf4life.implementor.House;import com.cbf4life.implementor.IPod;/*** @author cbf4Life [e-mail]* I'm glad to share my knowledge with you all.* 我要关心我自己的公司了*/public class Client {public static void main(String[] args) {House house = new House();System.out.println("-------房地产公司是这个样子运行的-------");//先找到我的公司HouseCorp houseCorp =new HouseCorp(house);//看我怎么挣钱houseCorp.makeMoney();System.out.println("\n");//山寨公司生产的产品很多，不过我只要制定产品就成了System.out.println("-------山寨公司是这样运行的-------");//ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new Clothes());ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new IPod());shanZhaiCorp.makeMoney();}}

既然万物都是运动的，我现在只有房地产公司和山寨公司，那以后我会不会增加一些其他的公司呢？或者房地产
公司会不会对业务进行细化，比如分为公寓房公司，别墅公司，以及商业房公司等等呢？那我告诉你，会的，绝
对的会的，但是你发觉没，这种变化对我们上面的类图没有大的修改，充其量是扩展，你看呀：
增加公司，你要么继承 Corp 类，要么继承 HouseCorp 或 ShanZhaiCorp，不用再修改原有的类了；
增加产品，继承 Product 类，或者继承 House 类，你要把房子分为公寓房、别墅、商业用房等等；
你都是在扩展，唯一你要修改的就是 Client 类，你类都增加了哪能不修改调用呢，也就是说 Corp 类和
Product 类都可以自由的扩展，而不会对整个应用产生太的变更，这就是桥梁模式。

_______________________________________________________________________________________________________

意图：

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

适用性：

你不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。

类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时Bridge 模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。

对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。

（C++）你想对客户完全隐藏抽象的实现部分。在C++中，类的表示在类接口中是可见的。

有许多类要生成。这样一种类层次结构说明你必须将一个对象分解成两个部分。Rumbaugh 称这种类层次结构为“嵌套的普化”（nested generalizations ）。

你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。一个简单的例子便是Coplien 的String 类[ Cop92 ]，在这个类中多个对象可以共享同一个字符串表示（StringRep ）。