桥接模式

1.定义

主要用意是为了实现抽象部分和现实部分脱耦，使他们各自可以独立的变化。

2.UML类图

3.代码

抽象产品类：

package com.designpattern.bridge;

/**
 * 抽象产品类
 * 
 * @author wujinsong
 */
public abstract class Product {
    /**
     * 产品被生成出来
     */
    public abstract void beProducted();
    
    /**
     * 产品被销售
     */
    public abstract void beSelled();
}

房子类：

package com.designpattern.bridge;

public class House extends Product {
    @Override
    public void beProducted() {
        System.out.println("生产房子...");
    }
    
    @Override
    public void beSelled() {
        System.out.println("销售房子...");
    }
    
}

山寨产品类：

package com.designpattern.bridge;

public class Cottage extends Product {
    
    @Override
    public void beProducted() {
        System.out.println("生产山寨产品");
    }
    
    @Override
    public void beSelled() {
        System.out.println("销售山寨产品");
    }
    
}

服装类：

package com.designpattern.bridge;

public class Clothes extends Product {
    
    @Override
    public void beProducted() {
        System.out.println("生产服装");
    }
    
    @Override
    public void beSelled() {
        System.out.println("销售服装");
    }
    
}

抽象公司类：

package com.designpattern.bridge;

/**
 * 抽象公司
 * 
 * @author wujinsong
 */
public abstract class Corp {
    // 定义一个抽象产品
    private Product product;
    
    public Corp(Product product) {
        this.product = product;
    }
    
    public Product getProduct() {
        return product;
    }
    
    public void setProduct(Product product) {
        this.product = product;
    }
    
    /**
     * 挣钱
     */
    public void makeMoney() {
        this.product.beProducted();
        this.product.beSelled();
    }
    
}

package com.designpattern.bridge;

/**
 * 房地产公司
 * 
 * @author wujinsong
 */
public class HouseCorp extends Corp {
    
    public HouseCorp(House house) {
        super(house);
    }
    
    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("房地产公司挣钱。。。");
    }
}

package com.designpattern.bridge;

/**
 * 山寨公司
 * 
 * @author wujinsong
 */
public class CottageCorp extends Corp {
    
    public CottageCorp(Product product) {
        super(product);
    }
    
    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("山寨公司挣钱");
    }
}

package com.designpattern.bridge;

/**
 * 服装公司
 * 
 * @author wujinsong
 */
public class ClothesCorp extends Corp {
    
    public ClothesCorp(Product product) {
        super(product);
    }
    
    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("服装公司挣钱");
    }
}

package com.designpattern.bridge;

/**
 * 客户类
 * 
 * @author wujinsong
 */
public class Client {
    public static void main(String[] args) {
        House house = new House();
        HouseCorp houseCorp = new HouseCorp(house);
        houseCorp.makeMoney();
        
        Cottage cottage = new Cottage();
        CottageCorp cottageCorp = new CottageCorp(cottage);
        cottageCorp.makeMoney();
        
        Clothes clothes = new Clothes();
        ClothesCorp clothesCorp = new ClothesCorp(clothes);
        clothesCorp.makeMoney();
    }
}

4.总结

在开发过程中，大家通常会遇到一个对象有两个变化的维度，而且这两个变化地非常剧烈，这种变化导错综交错的结果，使对象的设计变得困难，并且在对象数量和可扩展性上都带来了很大的麻烦。此时我们应当把这两个变化比较剧烈的维度拆离,然后用组合方式把他们组合在一起。这就是组合模式的思想。

5.适用场合

如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。设计要求实现化角色的任何改变不应当影响客户端，或者说实现化的改变对客户端是完全透明的。一个构件有多于一个的抽象化角色和实现化角色，系统需要他们之间进行动态耦合。