复习：GoF的23种设计模式之Bridge模式（结构型）

Bridge模式（桥梁）

谈这个模式前，我们先讨论一下，子类继承父类这个问题？

1. 当父类存在抽象方法时，子类继承父类，子类一般是实现父类的抽象方法。
2. 当父类非抽象类时，子类继承父类，子类一般是增加功能（方法）。

假如：我们经常继承父类，有实现父类抽象方法的，也有继承父类增加方法（功能）的。那么会出现如下图的层次结构：

不恰当的层次结构

这个一种不恰当的层次结构，因为第二次实现抽象类方法的子类2，子类2不能被增加功能的类FunctionOneConcreteCalss使用，所以又需要重新写增加功能。假如经常继承子类或者抽象类，用于增加功能（方法）或者重新实现抽象方法，那么整个类的层次结构将变的乱糟糟，后面根本无法维护。

错误示例代码

abstract class AbstractClass{
    public abstract void use();
}
class ConcreteClass extends AbstractClass{
    public void use() {
        System.out.println("第一次实现");
    }
}
class FunctionOneConcreteCalss extends ConcreteClass{
    public void print() {
        use();
        System.out.println("第一次增加功能");
    }
}
class ConcreteTwoClass extends AbstractClass{
    public void use() {
        for (int i = 0; i < 2; i++) {
            use();
        }
        System.out.println("第二次实现，系统现在使用的版本");
    }
}
//无端端要写一个类，就是因为实现第二个版本的ConcreteTwoClass
class FunctionOneConcreteTwoClass extends ConcreteTwoClass{
    public void print() {
        System.out.println("第一次增加功能");
        System.out.println("为了使用第二次实现的方法，再次写了一个相同的类");
    }
}
//后面又增加功能了，后面又重新实现抽象类了。。。。

这个错误是由于未分清楚类的层次结构。

类有两个层次结构： 

1. 类的功能层次结构：父类具有基本功能，在子类中增加新的功能。
2. 类的实现层次结构：父类通过声明抽象方法来定义接口，子类通过实现具体的方法来实现接口。

正确示例代码： 

public class BridgeTest {
    public static void main(String[] args) {
        Abstraction coldAbstraction = new Abstraction(new ColdWaterImplementor());
        coldAbstraction.use();
        System.out.println("----分界线-----");
        //使用新功能
        FunctionAbstraction functionAbstraction = new FunctionAbstraction(new ColdWaterImplementor());
        functionAbstraction.addUse();
        System.out.println("----分界线-----");
        //使用新实现
        Abstraction hotAbstraction = new Abstraction(new HotWaterImplementor());
        hotAbstraction.use();
    }
}
class Abstraction{    //当作一个抽象化的水龙头  //功能层次顶部
    private Implementor impl;
    public Abstraction(Implementor implementor) {
        this.impl = implementor;
    }
    public void open() {
        impl.open();
    }
    public void close() {
        impl.close();
    }
    public void use() {
        impl.open();
        impl.close();
    }
}
class FunctionAbstraction extends Abstraction{  //增加功能类
    public FunctionAbstraction(Implementor implementor) {
        super(implementor);
    }
    public void addUse() {   //强迫症，关两次水
        use();
        close();
    }
}
abstract class Implementor{  //抽象的水：冷水、热水    //实现层次顶部
    public abstract void open();    //进水
    public abstract void close();       //停水
}
class ColdWaterImplementor extends Implementor{
    @Override
    public void open() {
        System.out.println("出冷水啦！！");
    }
    @Override
    public void close() {
        System.out.println("停冷水啦！！");
    }
}
class HotWaterImplementor extends Implementor{
    @Override
    public void open() {
        System.out.println("出好热的热水啦！！");
    }
    @Override
    public void close() {
        System.out.println("停热水啦啦啦啦！！");
    }
}

UML类图