设计模式之禅- 桥梁模式
1.业务背景
我身价过亿，有两个大公司，一个是房地产公司，一个是服装制造业，这两个公司都很赚钱，天天帮我在累加财富，其实是什么公司我倒是不关心，我关心的是是不是在赚钱，赚了多少，这才是我关心的。
2.
定义一个公司的抽象类
public abstract class Corp {
/*
* 是公司就应该有生产，甭管是什么软件公司还是制造业公司
* 那每个公司的生产的东西都不一样，所以由实现类来完成
*/
protected abstract void produce();
/*
* 有产品了，那肯定要销售呀，不销售你公司怎么生存
*/
protected abstract void sell();
//公司是干什么的？赚钱的呀，不赚钱傻子才干
public void makeMoney(){
//每个公司都是一样，先生产
this.produce();
//然后销售
this.sell();
}
}
3.房地产公司
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("房地产公司赚大钱了...");
}
}
4.看服装公司
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("服装公司赚小钱...");
}
}
5.我要关心我自己的公司了
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();
}
}
运行结果：
-------房地产公司是这个样子运行的-------
房地产公司盖房子...
房地产公司出售房子...
房地产公司赚大钱了...
-------服装公司是这样运行的-------
服装公司生产衣服...
服装公司出售衣服...
服装公司赚小钱...
6.有一天我觉得赚钱速度太慢，通过生产山寨产品来赚钱，什么赚钱生产什么，赚过了高峰期就换个产品，打一枪换一个牌子，不承担售后成本、也不担心销路问题。
市场上前段时间比较火爆的是苹果 iPod，把服装厂改成 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("我赚钱呀...");
}
}
7.我这是个山寨工厂，要及时的生产出市场上流行产品，转型要快，要灵活，今天从生产 iPod 转为生产 MP4,明天再转为生产上网本，这个都需要灵活的变化，不要限制的太死，那问题来了，每次我的厂房，我的工人，我的设备都在，不可能每次我换个山寨产品我的厂子就彻底不要了，这不行，成本忒高了点，那怎么办？
Corp 类和 Product 类建立一个关联关系，可以彻底解决我以后山寨公司生产产品的问题
这是我整个集团公司的产品类
public abstract class Product {
//甭管是什么产品它总要是能被生产出来
public abstract void beProducted();
//生产出来的东西，一定要销售出去，否则扩本呀
public abstract void beSelled();
}
看 House 产品类：
public class House extends Product {
//豆腐渣就豆腐渣呗，好歹也是个房子
public void beProducted() {
System.out.println("生产出的房子是这个样子的...");
}
//虽然是豆腐渣，也是能够销售出去的
public void beSelled() {
System.out.println("生产出的房子卖出去了...");
}
}
Clothes 产品类：
public class Clothes extends Product {
public void beProducted() {
System.out.println("生产出的衣服是这个样子的...");
}
public void beSelled() {
System.out.println("生产出的衣服卖出去了...");
}
}
iPod 产品类：
public class IPod extends Product {
public void beProducted() {
System.out.println("生产出的iPod是这个样子的...");
}
public void beSelled() {
System.out.println("生产出的iPod卖出去了...");
}
}
产品类是有了，那我们再看 Corp 抽象类：
public abstract class Corp {
//定义一个产品对象，抽象的了，不知道具体是什么产品
private Product product;
//构造函数，由子类定义传递具体的产品进来
public Corp(Product product){
this.product = product;
}
//公司是干什么的？赚钱的呀，不赚钱傻子才干
public void makeMoney(){
//每个公司都是一样，先生产
this.product.beProducted();
//然后销售
this.product.beSelled();
}
}
房地产公司：
public class HouseCorp extends Corp {
//定义传递一个House产品进来
public HouseCorp(House house){
super(house);
}
//房地产公司很High了，赚钱，计算利润
public void makeMoney(){
super.makeMoney();
System.out.println("房地产公司赚大钱了...");
}
}
山寨公司的实现:
public class ShanZhaiCorp extends Corp {
//产什么产品，不知道，等被调用的才知道
public ShanZhaiCorp(Product product){
super(product);
}
//狂赚钱
public void makeMoney(){
super.makeMoney();
System.out.println("我赚钱呀...");
}
}
我要关心我自己的公司了：
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：
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();
}
}
8.Corp 类和Product 类都可以自由的扩展，而不会对整个应用产生太的变更，这就是桥梁模式。
桥梁模式的通用类图
中间那根带箭头的线了吗？是不是类似一个桥，连接了两个类？所以就叫桥梁模式。桥梁模式的优点就是类间解耦，我们上面已经提到，两个角色都可以自己的扩展下去，不会相互影响，这个也符合 OCP 原则
