模板方法（Template Method）

Intent

定义算法框架，并将一些步骤的实现延迟到子类。

通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。

Class Diagram

模板方法（Template Method） - 图1

Implementation

冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。

模板方法（Template Method） - 图2

  1. public abstract class CaffeineBeverage {
  3.     final void prepareRecipe() {
  4.         boilWater();
  5.         brew();
  6.         pourInCup();
  7.         addCondiments();
  8.     }
  10.     abstract void brew();
  12.     abstract void addCondiments();
  14.     void boilWater() {
  15.         System.out.println("boilWater");
  16.     }
  18.     void pourInCup() {
  19.         System.out.println("pourInCup");
  20.     }
  21. }
  1. public class Coffee extends CaffeineBeverage {
  2.     @Override
  3.     void brew() {
  4.         System.out.println("Coffee.brew");
  5.     }
  7.     @Override
  8.     void addCondiments() {
  9.         System.out.println("Coffee.addCondiments");
  10.     }
  11. }
  1. public class Tea extends CaffeineBeverage {
  2.     @Override
  3.     void brew() {
  4.         System.out.println("Tea.brew");
  5.     }
  7.     @Override
  8.     void addCondiments() {
  9.         System.out.println("Tea.addCondiments");
  10.     }
  11. }
  1. public class Client {
  2.     public static void main(String[] args) {
  3.         CaffeineBeverage caffeineBeverage = new Coffee();
  4.         caffeineBeverage.prepareRecipe();
  5.         System.out.println("-----------");
  6.         caffeineBeverage = new Tea();
  7.         caffeineBeverage.prepareRecipe();
  8.     }
  9. }
  1. boilWater
  2. Coffee.brew
  3. pourInCup
  4. Coffee.addCondiments
  5. -----------
  6. boilWater
  7. Tea.brew
  8. pourInCup
  9. Tea.addCondiments

JDK

  • java.util.Collections#sort()
  1.     @SuppressWarnings({"unchecked", "rawtypes"})
  2.     default void sort(Comparator<? super E> c) {
  3.         Object[] a = this.toArray();
  4.         Arrays.sort(a, (Comparator) c);
  5.         ListIterator<E> i = this.listIterator(); // listIterator是延迟到子类实现的
  6.         for (Object e : a) {
  7.             i.next();
  8.             i.set((E) e);
  9.         }
  10.     }
  • java.util.AbstractList#indexOf()
  1.     public int indexOf(Object o) {
  2.         ListIterator<E> it = listIterator(); // 同上
  3.         if (o==null) {
  4.             while (it.hasNext())
  5.                 if (it.next()==null)
  6.                     return it.previousIndex();
  7.         } else {
  8.             while (it.hasNext())
  9.                 if (o.equals(it.next()))
  10.                     return it.previousIndex();
  11.         }
  12.         return -1;
  13.     }

java.lang.ClassLoader

  1.     protected Class<?> loadClass(String name, boolean resolve)
  2.         throws ClassNotFoundException
  3.     {
  4.         synchronized (getClassLoadingLock(name)) {
  5.             // First, check if the class has already been loaded
  6.             Class<?> c = findLoadedClass(name); // 来检查是否已经加载类
  7.             if (c == null) {
  8.                 long t0 = System.nanoTime();
  9.                 try {
  10.                     if (parent != null) {
  11.                         c = parent.loadClass(name, false); // 让父加载器尝试加载加载
  12.                     } else {
  13.                         c = findBootstrapClassOrNull(name); // 让 bootstrap class loader尝试加载
  14.                     }
  15.                 } catch (ClassNotFoundException e) {
  16.                     // ClassNotFoundException thrown if class not found
  17.                     // from the non-null parent class loader
  18.                 }
  20.                 if (c == null) {
  21.                     // If still not found, then invoke findClass in order
  22.                     // to find the class.
  23.                     long t1 = System.nanoTime();
  24.                     c = findClass(name); // 模板设计模式，如果都没有找到的话，则从findCLass中去找，这个findClass ,子类去复写这个方法
  26.                     // this is the defining class loader; record the stats
  27.                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  28.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  29.                     sun.misc.PerfCounter.getFindClasses().increment();
  30.                 }
  31.             }
  32.             if (resolve) {
  33.                 resolveClass(c);
  34.             }
  35.             return c;
  36.         }
  37.     }

ClassLoader实用了 模板设计模式

1、首先看是否有已经加载好的类。

2、如果父类加载器不为空，则首先从父类类加载器加载。

3、如果父类加载器为空，则尝试从启动加载器加载。

4、如果两者都失败，才尝试从findClass方法加载。 // 子类来实现

  • java.io.InputStream#skip() // 都是在子类中才实现
  • java.io.InputStream#read()