模板模式（Template Method Pattern）是一种行为设计模式，它定义了一个操作中的算法骨架，而将一些步骤延迟到子类中实现。这样，子类可以在不改变算法结构的情况下重定义算法的某些特定步骤。
### 主要组成部分
1. **抽象类（Abstract Class）**：定义了一个或多个抽象方法，这些方法称为“基本方法”（Primitive Methods）。同时定义了一个模板方法（Template Method），它调用基本方法和其他具体方法来实现算法的骨架。
2. **具体类（Concrete Classes）**：实现抽象类中的基本方法，完成具体的业务逻辑。
### 实现步骤
1. 定义一个抽象类，声明基本方法和模板方法。
2. 在抽象类中实现模板方法，调用基本方法。
3. 创建具体类，实现抽象类中的基本方法。
4. 客户端调用具体类中的模板方法。
### 示例代码
假设我们要实现一个文本处理程序，该程序可以处理不同类型的文本文件，如普通文本文件和加密文本文件。我们可以使用模板模式来定义处理文本文件的基本步骤，然后让子类实现具体的处理逻辑。
#### 抽象类
```java
public abstract class TextProcessor {
// 模板方法
public final void processText(String filename) {
String text = readText(filename);
text = preprocess(text);
text = transformText(text);
text = postprocess(text);
writeText(text);
}
// 基本方法
protected abstract String readText(String filename);
protected abstract String preprocess(String text);
protected abstract String transformText(String text);
protected abstract String postprocess(String text);
protected abstract void writeText(String text);
}
```
#### 具体类：普通文本处理器
```java
public class PlainTextProcessor extends TextProcessor {
@Override
protected String readText(String filename) {
// 读取普通文本文件
System.out.println("Reading plain text from " + filename);
return "This is plain text.";
}
@Override
protected String preprocess(String text) {
// 预处理普通文本
System.out.println("Preprocessing plain text");
return text.toLowerCase();
}
@Override
protected String transformText(String text) {
// 转换普通文本
System.out.println("Transforming plain text");
return text.replace("plain", "normal");
}
@Override
protected String postprocess(String text) {
// 后处理普通文本
System.out.println("Postprocessing plain text");
return text.trim();
}
@Override
protected void writeText(String text) {
// 写入普通文本
System.out.println("Writing plain text: " + text);
}
}
```
#### 具体类：加密文本处理器
```java
public class EncryptedTextProcessor extends TextProcessor {
@Override
protected String readText(String filename) {
// 读取加密文本文件
System.out.println("Reading encrypted text from " + filename);
return "This is encrypted text.";
}
@Override
protected String preprocess(String text) {
// 解密文本
System.out.println("Decrypting text");
return text.replace("encrypted", "decrypted");
}
@Override
protected String transformText(String text) {
// 转换加密文本
System.out.println("Transforming encrypted text");
return text.toUpperCase();
}
@Override
protected String postprocess(String text) {
// 后处理加密文本
System.out.println("Postprocessing encrypted text");
return text.trim();
}
@Override
protected void writeText(String text) {
// 写入加密文本
System.out.println("Writing encrypted text: " + text);
}
}
```
#### 客户端
```java
public class Client {
public static void main(String[] args) {
TextProcessor plainTextProcessor = new PlainTextProcessor();
plainTextProcessor.processText("plain.txt");
TextProcessor encryptedTextProcessor = new EncryptedTextProcessor();
encryptedTextProcessor.processText("encrypted.txt");
}
}
```
### 运行结果
```
Reading plain text from plain.txt
Preprocessing plain text
Transforming plain text
Postprocessing plain text
Writing plain text: this is normal text.
Reading encrypted text from encrypted.txt
Decrypting text
Transforming encrypted text
Postprocessing encrypted text
Writing encrypted text: THIS IS DECRYPTED TEXT.
```
### 总结
模板模式通过定义一个算法的骨架，将具体步骤的实现延迟到子类中，从而实现了代码的复用和扩展性。这种模式特别适用于以下场景：
- 算法的步骤固定，但某些步骤的具体实现可能因环境或需求而异。
- 需要在不改变算法结构的情况下，对算法的某些部分进行定制。
通过使用模板模式，可以确保算法的结构一致，同时允许子类灵活地实现具体的细节。
