不一样的模板模式(设计模式十一)

前言

这个补一章，因为当时觉得很简单所以就跳过了，所以补齐十一。

什么是模板模式呢？这是一个晚绑定非常好的体现。把定义抄一下哈：一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

这节主要介绍一下晚绑定是啥，增强理解，这个模式很简单的。

正文

就是有这样一个场景:

public abstract class Library{
   abstract void part1();
   bool part2()
   {
       return xx;//xx 表示true 或者false
   }
   void part3()
   {
   }
}

public class Appliaction:Library{
   override void part1(){
      //具体实现
   }
}

然后呢,main中这样调用的。

Appliaction appliaction=new Appliaction();
appliaction.part1();
//一些操作
if(appliaction.part2())
{
   appliaction.part3();
}

如果:

appliaction.part1();
//一些操作
if(appliaction.part2())
{
   appliaction.part3();
}

是稳定的，那么可以提取到Appliaction中，那么可以这样:

public abstract class Application{
   override void part1()
  {
  }
   void run()
   {
      part1();
     //一些操作
     if(part2())
     {
        part3();
     }
   }
}

这样做就好了点，但是最好能放在Library中。

因为application 调用的是library 中的函数，因为application 比library 晚实现，那么调用早实现的，就是晚绑定,反过来就是早绑定了。

如果这样的话，会跟好一点:

public abstract class Library{
   abstract void part1();
   bool part2()
   {
       return xx;//xx 表示true 或者false
   }
   void part3()
   {
   }
   void run()
   {
      part1();
     //一些操作
     if(part2())
     {
        part3();
     }
   }
}

那么问题来了，为什么晚绑定比早绑定好？

因为如果把具体实现放在子类中，可以不改变某种算法即可定义该算法的某种步骤，也就是说run 方法放在了一个稳定的类中封装起来了。

可能这样在library 和application中不好理解，那么在main 和application 那个变化中就很好理解了，如果把步骤放在main中，做同样的操作，是不是又要写一遍。

然后放在application中，如果run是稳定的，那么是不是library 的继承类是不是又要写一遍？这样复用性，可读性，还有维护性都降低了很多。