设计模式之Bridge模式(桥接模式)
这几天重新去看spring系列的框架了（也又次体会到了理解设计模式在学习框架时的好处），没有接着写，发生了一些事，又少了些许束缚，但结果对向往自由的我来说总是好的，虎入山林，龙归沧海，听听音乐，整理整理博客。
书上的介绍比较简单，抽象，又看了一些其他东西才理解了一些。首先来介绍一下类的两个层次结构：功能层次结构和实现层次结构。
所谓功能层次结构，我们现在有一个类ActionSomething，想在它上面拓展新的功能，直接的方法就是继承他，添加一个派生类ActionSomethingGood，如果再想拓展功能会继续继承ActionSomethingGood，接着派生出ActionSomethingBetter，这样就是一个三层的功能层次结构，不过通常来说，类的层次结构不应过深。
然后是实现层次结构，模板方法模式中，我们了解了抽象类的强大之处，父类不但对子类规定了要实现的接口，还强制约束了这些接口的工作流程。父类的任务就是定义接口，而子类的任务就是实现这些抽象方法，这也是一种层次结构。例如，子类ConcreteClass实现了父类AbstractClass的抽象方法，构成了一个两层的实现结构：
但这个地方并非用来新增功能，而是为了实现新的任务分组，这就是类的实现层次结构，如果之后要以其他方式实现AbstractClass，只需再继承并实现类AnotherConcreteClass，类的层次结构发生了点变化：
我个人的简单理解就是功能层次结构就意味着功能的增加，而实现层次结构意味着功能的修改。
接下来是重点，也是桥接模式的主要优点：分离类的功能层次结构和实现层次结构。当然，如果只是简单的分离，两者之间必然缺少某种联系，因此还需要在二者之间搭起一个桥梁。书上说Bridge模式的作用就是搭建这座桥梁，但我个人的理解是如何分离类的两个层次结构也许更加重要。
说了不少，大伙可能还没理解，还是看一些代码更加容易理解，书上的例子我感觉可能还是有点抽象，因此我来写一个从别的地方看到的例子。
假如现在有一个生产各种笔的工厂，一开始规模较小，只生产铅笔和钢笔，笔的功能比较少，只有书写的功能，但不同笔在书写之前要做的操作是不一样的，我们可以得到以下的设计：
首先是一个抽象的笔类(此处使用了一点模板方法模式)：
/**
* @author lenovo
* @title: AbstractPen
* @projectName LearnDesignMode
* @description: 抽象笔类
* @date 2022/5/1523:18
*/
public abstract class AbstractPen {
//笔在写之前要进行的操作 不同笔不一样，铅笔，钢笔等
abstract void beforePrint();
public void printSomething(String context) {
beforePrint();
System.out.println("写了" + context);
}
}
接着我们来看铅笔和钢笔的实现类：
public class Pencil extends AbstractPen {
@Override
void beforePrint() {
System.out.println("铅笔使用铅笔刀削好了");
}
}
public class Pen extends AbstractPen {
@Override
void beforePrint() {
System.out.println("钢笔拔下了笔帽，吸足了墨水");
}
}
使用Main方法测试一下：
public class Main {
public static void main(String[] args) {
AbstractPen pen = new Pen();
AbstractPen pencil = new Pencil();
String context = "Hello,World";
pen.printSomething(context);
pencil.printSomething(context);
}
}
输出结果：
钢笔拔下了笔帽，吸足了墨水
写了Hello,World
铅笔使用铅笔刀削好了
写了Hello,World
现在来看万事大吉，工厂在不断生产出笔来获取利润，慢慢的工厂做大，为卖出更多的笔，赚取更多利润，老板不再满足他的笔只有书写的功能，开始增加花里胡哨的功能，我们大可以直接由铅笔类和钢笔类进行派生进而增加新的功能，也遵守了开闭原则：
public class GoodPencil extends Pencil{
public void newAbility() {
System.out.println("第一个花里胡哨的功能");
}
}
public class GoodPen extends Pen {
public void newAbility() {
System.out.println("第一个花里胡哨的功能");
}
}
使用Main测试下：
public class Main {
public static void main(String[] args) {
GoodPen pen = new GoodPen();
GoodPencil pencil = new GoodPencil();
String context = "Hello,World";
pen.printSomething(context);
pen.newAbility();
pencil.printSomething(context);
pencil.newAbility();
}
}
输出结果：
钢笔拔下了笔帽，吸足了墨水
写了Hello,World
第一个花里胡哨的功能
铅笔使用铅笔刀削好了
写了Hello,World
第一个花里胡哨的功能
好的，新增两个类之后，新的功能增加了，也没有破坏设计程序的开闭原则，看起来我们之前的设计好像是没有问题，有新的功能拓展起来非常棒。但老板仍不满足现状，又决定开始制造中性笔，新增一个中性笔类：
public class RollerBallPen extends AbstractPen {
@Override
void beforePrint() {
System.out.println("中性笔拔下了笔帽");
}
public void newAbility() {
System.out.println("第一个花里胡哨的功能");
}
}
测试下并输出：
public class Main {
public static void main(String[] args) {
String context = "Hello,World";
RollerBallPen rollerBallPen = new RollerBallPen();
rollerBallPen.printSomething(context);
rollerBallPen.newAbility();
}
}
中性笔拔下了笔帽
写了Hello,World
第一个花里胡哨的功能
结果还不错，因为新增了一种笔，我们新增了一个类，还是达到了要求，但隐约感觉好像开始有问题了。果然，人的贪欲是无止境的。第二天，老板又要给所有的笔增加第二个花里胡哨的新功能。现在我们要怎么做，接着派生之前的三个类，增加新功能吗，类似下面的处理：
public class BetterPencil extends GoodPencil {
public void secondNewAbility() {
System.out.println("第二个花里胡哨的功能");
}
}
要求肯定是可以达到的，可就因为一个小小功能的增加，我们要再增加三个类似的类来完成，如果后面再有新的笔呢，再来个马克笔，毛笔，水彩笔等等，到那时我们如果再新增一个新的功能会怎么样呢，类的个数是指数式增长的，想想就很恐怖。
造成如此的原因是什么，就是因为每种笔在使用之前的处理不同，这就是类的实现层次结构，新功能的添加呢，不就是类的功能层次结构吗，我们正可以通过桥接模式对这两种结构进行分离，来看改变之后的代码：
首先是AbstractPen，他不再是一个抽象类（主要因为在此处已没有要被子类实现的功能），并把之前的笔在使用之前的方法封装在了接口PenHandle中，在AbstractPen中引入即可：
public class AbstractPen {
private PenHandle penHandle;
public AbstractPen(PenHandle penHandle) {
this.penHandle = penHandle;
}
public void printSomething(String context) {
penHandle.beforePrint();
System.out.println("写了" + context);
}
}
public interface PenHandle {
//使用前要进行的操作
void beforePrint();
}
现在我们来实现三种笔的预处理：
public class PencilHandleImpl implements PenHandle {
@Override
public void beforePrint() {
System.out.println("铅笔使用铅笔刀削好了");
}
}
public class PenHandleImpl implements PenHandle {
@Override
public void beforePrint() {
System.out.println("钢笔拔下了笔帽，吸足了墨水");
}
}
public class RollerBallPenHandleImpl implements PenHandle {
@Override
public void beforePrint() {
System.out.println("中性笔拔下了笔帽");
}
}
那要如何生产三种笔呢，直接看Main方法：
public class Main {
public static void main(String[] args) {
String context = "Hello,World";
PenHandle pen = new PenHandleImpl();
PenHandle pencil = new PencilHandleImpl();
PenHandle rollerBallPen = new RollerBallPenHandleImpl();
AbstractPen concretePen = new AbstractPen(pen);
AbstractPen concretePencil = new AbstractPen(pencil);
AbstractPen concreteRollerBallPen = new AbstractPen(rollerBallPen);
concretePen.printSomething(context);
concretePencil.printSomething(context);
concreteRollerBallPen.printSomething(context);
}
}
来看结果：
钢笔拔下了笔帽，吸足了墨水
写了Hello,World
铅笔使用铅笔刀削好了
写了Hello,World
中性笔拔下了笔帽
写了Hello,World
非常好的完成了任务，那要新增功能呢，只需继承AbstractPen并拓展即可：
public class GoodPen extends AbstractPen {
public GoodPen(PenHandle penHandle) {
super(penHandle);
}
public void newAbility() {
System.out.println("第一个花里胡哨的功能");
}
}
测试一下并输出：
public class Main {
public static void main(String[] args) {
String context = "Hello,World";
PenHandle pen = new PenHandleImpl();
PenHandle pencil = new PencilHandleImpl();
PenHandle rollerBallPen = new RollerBallPenHandleImpl();
GoodPen concretePen = new GoodPen(pen);
GoodPen concretePencil = new GoodPen(pencil);
GoodPen concreteRollerBallPen = new GoodPen(rollerBallPen);
concretePen.printSomething(context);
concretePen.newAbility();
concretePencil.printSomething(context);
concretePencil.newAbility();
concreteRollerBallPen.printSomething(context);
concreteRollerBallPen.newAbility();
}
}
钢笔拔下了笔帽，吸足了墨水
写了Hello,World
第一个花里胡哨的功能
铅笔使用铅笔刀削好了
写了Hello,World
第一个花里胡哨的功能
中性笔拔下了笔帽
写了Hello,World
第一个花里胡哨的功能
如果还有新的功能呢，依旧是继承，然后派生即可，而不是有多少种笔就新增多少类，那是非常糟糕的处理。
此时我们就实现了类的功能层次结构（新增功能）和实现层次结构（修改功能）的分离，以上我个人对桥接模式的一些理解。
这篇文章可以说是我写的比较认真的，写的时间也比较长，希望看到这里的各位点赞支持一下，大家一起进步。