模板方法

• 意图

定义一个操作中算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

• 动机

一个模板方法用一些抽象的操作定义一个算法，而子类将重新定义这些操作以提供具体的行为，满足它们各自的需求。

• 适用性

• 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
• 各子类中公共的行为应被提取出来并集中到一个公共的父类中以避免代码重复。
• 控制子类扩展，模板方法只在特定点调用“hook”操作，这样只允许在这些点进行扩展。

• 真实的模板方法

jdk源码HashMap与LinkedHashMap实现，hash算法是一种快速的随机存取算法。
HashMap构造函数中定义了算法的骨架，并定义了一个缺省的钩子作为扩展点，供子类实现。

   /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and load factor.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();  //钩子
    }

  /**
     * Initialization hook for subclasses. This method is called
     * in all constructors and pseudo-constructors (clone, readObject)
     * after HashMap has been initialized but before any entries have
     * been inserted.  (In the absence of this method, readObject would
     * require explicit knowledge of subclasses.)
     */
    void init() {
    }

LinkedHashMap调用父类的构造方法，同时为钩子提供了一个实现，赋予了HashMap顺序存取的能力。

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{
  /**
     * Constructs an empty insertion-ordered <tt>LinkedHashMap</tt> instance
     * with the specified initial capacity and load factor.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

   /**
     * Called by superclass constructors and pseudoconstructors (clone,
     * readObject) before any entries are inserted into the map.  Initializes
     * the chain.
     */
    @Override
    void init() {
        header = new Entry<>(-1, null, null, null);
        header.before = header.after = header;
    }
}

这样则将存储的职责交托于父类，而自身只关注于存储顺序的维护。
示例为jdk1.7，jdk1.8已不再采用这种方式

• 参考

设计模式----可复用面向对象软件的基础