Template模板模式可以这样理解：一个抽象类公开定义了执行它的方法的方式/模板，它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
通俗来说，可以这样理解： 定义一个操作中算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。
比如：完成一件事情，有固定的数个步骤，但是每个步骤根据对象的不同，而实现细节不同；就可以在父类中定义一个完成该事情的总方法，按照完成事件需要的步骤去调用其每个步骤的实现方法。每个步骤的具体实现，由子类完成。
抽象父类（AbstractClass）：实现了模板方法，定义了算法的骨架。
具体类（ConcreteClass)：实现抽象类中的抽象方法，即不同的对象的具体实现细节。
我们看如下代码：
package Paint;
//抽象父类
public abstract class DodishTemplate {
/**
* 具体的整个过程
*/
protected void dodish() {
this.preparation();
this.doing();
this.carriedDishes();
}
/**
* 备料
*/
public abstract void preparation();
/**
* 做菜
*/
public abstract void doing();
/**
* 上菜
*/
public abstract void carriedDishes();
}
package Paint;
/**
* 子类：西红柿炒蛋
*/
public class EggsWithTomato extends DodishTemplate {
@Override
public void preparation() {
System.out.println("洗并切西红柿，打鸡蛋。");
}
@Override
public void doing() {
System.out.println("鸡蛋倒入锅里，然后倒入西红柿一起炒。");
}
@Override
public void carriedDishes() {
System.out.println("将炒好的西红寺鸡蛋装入碟子里，端给客人吃。");
}
}
package Paint;
/**
* 子类：红烧肉
*/
public class Bouilli extends DodishTemplate {
@Override
public void preparation() {
System.out.println("切猪肉和土豆。");
}
@Override
public void doing() {
System.out.println("将切好的猪肉倒入锅中炒一会然后倒入土豆连炒带炖。");
}
@Override
public void carriedDishes() {
System.out.println("将做好的红烧肉盛进碗里端给客人吃。");
}
}
package Paint;
// 测试
public class TestCooking {
public static void main(String[] args) {
DodishTemplate eggsWithTomato = new EggsWithTomato();
eggsWithTomato.dodish();
System.out.println("-----------------------------");
DodishTemplate bouilli = new Bouilli();
bouilli.dodish();
}
}
// 执行结果如下：
#洗并切西红柿，打鸡蛋。
#鸡蛋倒入锅里，然后倒入西红柿一起炒。
#将炒好的西红寺鸡蛋装入碟子里，端给客人吃。
#-----------------------------
#切猪肉和土豆。
#将切好的猪肉倒入锅中炒一会然后倒入土豆连炒带炖。
#将做好的红烧肉盛进碗里端给客人吃。
模板设计模式看代码，不难理解，在加载配置文件的时候，可以有不同的加载方式，如根据文件系统目录加载配置文件（FileSystemXmlApplicationContext），类路径加载配置文件(ClassPathXmlApplicationContext)，以及根据项目上下文目录(XmlWebApplicationContext)加载配置文件。
这个在加载的过程中就使用了模板设计模式，模板设计模式的意图：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
主要解决：一些方法通用，却在每一个子类都重新写了这一方法。
何时使用：有一些通用的方法。
如何解决：将这些通用算法抽象出来。
关键代码：在抽象类实现，其他步骤在子类实现。
优点：
1、封装不变部分，扩展可变部分。具体细节步骤实现定义在子类中，子类定义详细处理算法是不会改变算法整体结构
2、提取公共代码，便于维护。代码复用的基本技术，在数据库设计中尤为重要。
3、行为由父类控制，子类实现。存在一种反向的控制结构，通过一个父类调用其子类的操作，通过子类对父类进行扩展增加新的行为，符合“开闭原则”。
缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。
使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。
注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。
更多设计模式，我们可以到该网站学习：
http://www.runoob.com/design-pattern/template-pattern.html
