桥梁模式

桥梁模式:其实就是把抽象和实现解耦，解决了继承的缺点，实现可以不用受抽象的约束，不用再绑定在一个固定的抽象层次上。

公司产品桥梁模式案例

   如果使用普通的继承，那动态具有好多种公司，房地产、服装公司、餐饮公司，然而房地产公司又可以分为 公寓房公司、别墅房公司等等...这样的话，子类就太多啦，扩展也不是很方便。

  如果使用桥梁模式，把公司和产品解耦，每种类型的公司可以与任意的产品组合。且产品不用受公司抽象类的约束，扩展方便

具体的代码如下:

Product.java  实现角色代码如下

package com.designModel.Bridgemodel;

/**
 * 实现角色 的抽象类
 */
public abstract class Product {

    //生产
    public abstract void product();

    //销售
    public abstract void sell();
}

Copr.java 抽象角色

package com.designModel.Bridgemodel;

/**
 * 抽象角色
 */
public abstract class Copr {


    //实现角色
    private Product product;

    public Copr(Product product) {
        this.product = product;
    }

    //公司的目的就是赚钱
    public void makeMoney() {
        this.product.product();
        this.product.sell();
    }
}

具体的抽象角色

HouseCopr.java 

package com.designModel.Bridgemodel;

public class HouseCopr extends Copr {

    public HouseCopr(Product product) {
        super(product);
    }

    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("房地产公司赚大钱");
    }
}

ShanZhaiCopr.java

package com.designModel.Bridgemodel;

public class ShanZhaiCopr extends Copr {

    public ShanZhaiCopr(Product product) {
        super(product);
    }

    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("山寨公司赚钱");
    }
}

 具体的实现角色

Clothes.java

package com.designModel.Bridgemodel;

public class Clothes extends Product {

    @Override
    public void product() {
        System.out.println("生成衣服");
    }
    @Override
    public void sell() {
        System.out.println("销售衣服");
    }
}

 Ipod.java

package com.designModel.Bridgemodel;

public class Ipod extends Product {
    @Override
    public void product() {
        System.out.println("生产Ipod产品");
    }
    @Override
    public void sell() {
        System.out.println("销售Ipod产品");
    }
}

Client.java调用类

package com.designModel.Bridgemodel;

public class Client {

    public static void main(String... args) {

        HouseCopr houseCopr = new HouseCopr(new Clothes());
        houseCopr.makeMoney();
        System.out.println("--------------------");
        ShanZhaiCopr shanZhaiCopr = new ShanZhaiCopr(new Ipod());
        shanZhaiCopr.makeMoney();
        System.out.println("------------------");
        ShanZhaiCopr shanZhaiCopr1 = new ShanZhaiCopr(new Clothes());
        shanZhaiCopr1.makeMoney();
    }
}

桥梁模式关系类图如下

Abstraction---------------抽象化角色

它的主要指责是定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类

Implementor---------------实现化角色

它是接口或抽象类，定义角色必需的行为和属性

RefinedAbstraction--------------修正抽象化角色

它引用实现化角色对抽象化角色进行修正

ConcreteImplementor---------具体实现化角色

它实现接口或抽象类定义的方法和属性

Implementor.java

package com.designModel.Bridgemodel;

public interface Implementor {

    void doSomething();

    void doAnything();


}

ConcreteImplementor1.java

package com.designModel.Bridgemodel;

public class ConcreteImplementor1 implements Implementor {

    @Override
    public void doSomething() {

    }

    @Override
    public void doAnything() {

    }
}

Abstraction.java

package com.designModel.Bridgemodel;

public abstract class Abstraction {

    private Implementor implementor;

    public Abstraction(Implementor _impl) {
        this.implementor = _impl;
    }

    public void request() {
        this.implementor.doSomething();
    }

    public Implementor getImp() {
        return implementor;
    }
}

具体抽象化角色

package com.designModel.Bridgemodel;

public class RefinedAbstraction extends Abstraction {

    public RefinedAbstraction(Implementor _impl) {
        super(_impl);
    }
    //修正父类的行为
    @Override
    public void request() {
        super.request();
        super.getImp().doAnything();
    }
}