大话编程-桥接模式

桥接模式（Bridge Pattern）

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

动机

当一个抽象可以有多个实现时，通常用继承来协调它们。抽象类定义该对象的接口，而具体的子类则用不同的方式加以实现。但是此方法有时不够灵活。继承机制将抽象部分与它的实现部分固定在一起，使得难以对抽象部分独立地进行修改，扩充和重用。

适用场景

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

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

• 对一个抽象的实现部分的修改对客户不产生影响。

• 多个对象共享实现，但同时要求客户并不知道这一点。

结构

代码示例

//抽象类，电视机相关操作
public abstract class RemoteCotrol {

    private TV tv;

    public RemoteCotrol(TV tv) {
        this.tv = tv;
    }

    public TV getTv() {
        return tv;
    }

    public abstract void on();
    public abstract void off();
    public abstract void setChannel();
}

//tv接口 
public interface TV {

    void on();

    void off();

    void tuneChannel();
}

//tv接口实现类，实现电视剧相关的操作
public class RCA implements TV {

    @Override
    public void on() {
        System.out.println("rca on");
    }

    @Override
    public void off() {
        System.out.println("rca off");
    }

    @Override
    public void tuneChannel() {
        System.out.println("rca CCTV");
    }
}

//tv接口实现类，实现电视剧相关的操作
public class Sony implements TV {
    @Override
    public void on() {
        System.out.println("sony on");
    }

    @Override
    public void off() {
        System.out.println("sony off");
    }

    @Override
    public void tuneChannel() {
        System.out.println("sony cctv");
    }
}

//抽象实现类，关联接口，使用接口实现抽象类的电视剧相关操作
public class ConsreteRemode extends RemoteCotrol {

    public ConsreteRemode(TV tv) {
        super(tv);
    }

    @Override
    public void on() {
        getTv().on();
    }

    @Override
    public void off() {
        getTv().off();
    }

    @Override
    public void setChannel() {
        getTv().tuneChannel();
    }
}

public class Client{
  public static void main(String[] args) {
        RemoteCotrol sony = new ConsreteRemode(new Sony());
        sony.on();

        RemoteCotrol rca = new ConsreteRemode(new RCA());
        rca.on();
    }
}

: sony on

rca on

总结

桥接模式可以帮助我们使抽象和实现完全解耦。此模式也符合合成/聚合复用原则，即优先使用对象的合成或聚合，而不是继承。究其原因是因为继承是一种强耦合的结构，父类变，子类就必须变。

欢迎关注微信公众号

访问更多文章