栗子

定义抽象公司

public abstract class Corp{
    // 公司生产内容
    protected abstract void produce();
    // 销售
    protected abstract void sell();
    // 赚钱
    public void makeMoney(){
        // 生产
        this.produce();
        // 销售
        this.sell();
    }
}

上方是模板方法
下面是房地产公司

public class HouseCorp extends Corp{
    // 盖房子
    protected void produce(){
        // 盖房子
    }
    // 卖房子
    protected void sell(){
        // 卖房子
    }
    // 赚钱
    public void makeMoney(){
        super.makeMoney();
        // 赚钱
    }
}

服装公司

public class ClothesCorp extends Corp{
    // 生产衣服
    protected void produce(){
        // 生产衣服
    }
    protected void sell(){
        // 出售衣服
    }
    public void makeMoney(){
        super.makeMoney();
        // 赚钱
    }
}

最后编写场景

public class Client{
    public static void main(String[] args){
        HouseCorp houseCorp = new HouseCorp();
        houseCorp.makeMoney();
        ClothesCorp clothesCorp = new ClothesCorp();
        clothesCorp.makeMoney();
    }
}

更改

企业改头换面，生产另外的产品
山寨公司

public class IPodCorp extends Corp{
    // 生产
    protected void produce(){
        // 生产
    }
    // 畅销
    protected void sell(){
        // 畅销
    }
    // 赚钱
    public void makeMoney(){
        super.makeMoney();
        // 赚钱
    }
}

赚钱

public class Client{
    public static void main(String[] args){
        // 房地产
        HouseCorp houseCorp = new HouseCorp();
        // 挣钱
        houseCorp.makeMoney();
        // 山寨公司
        IPodCorp ipodCorp = new IPodCorp();
        ipodCorp.makeMoney();
    }
}

继续更改

公司和产品分离，让其之间建立关系

// 抽象产品类
public abstract class Product{
    // 生产
    public abstract void beProducted();
    // 销售
    public abstract void beSelled();
}

// 房子
public class House extends Product{
    // 豆腐渣房子
    public void beProducted(){
        // 生产
    }
    // 销售
    public void beSelled(){
        // 销售
    }
}

继续

public class IPod extends Product{
    public void beProducted(){
        // 生产
    }
    public void beSelled(){
        // 销售
    }
}

下面是抽象公司类

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);
    }
    // 赚钱
    public void makeMoney(){
        super.makeMoney();
        // 赚钱
    }
}

山寨公司

public class ShanZhaiCorp extends Corp{
    // 产品
    public ShanZhaiCorp(Product product){
        super(product);
    }
    // 赚钱
    public void makeMoney(){
        super.makeMoney();
        // 赚钱
    }
}

最后书写场景

public class Client{
    public static void main(String[] args){
        House house = new House();
        // 房地产公司
        HouseCorp houseCorp = new HouseCorp(house);
        // 赚钱
        houseCorp.makeMoney();
        // 生产产品
        ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new IPod());
        ShanZhaiCorp.makeMoney();
    }
}

此时在目前状态下，若要生产服装，只需要继承Product类，定义一个服装类即可

public class Clothes extends Product{
    public void beProducted(){
        // 生产服装
    }
    public void beSelled(){
        // 卖衣服
    }
}

最后书写场景类

public class Client{
    public static void main(String[] args){
        House house = new House();
        // 房地产公司
        HouseCorp houseCorp = new HouseCorp(house);
        // 挣钱
        houseCorp.makeMoney();
        // 山寨公司生产
        ShanZhaiCorp.shanZhaiCorp = new ShanZhaiCorp(new Clothes());
        ShanZhai.makeMoney();
    }
}

总结

桥梁模式，抽象和实现解耦，需要的时候，将实现注入抽象。