模板方法模式是一种行为设计模式，它在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。
解决什么问题？
如果类与类之间使用的算法框架一样，仅有少部分算法框架步骤不同。在继承的关系中仅需要重写不同部分的代码，使用模板模式是很合适的。
实现步骤：
- 定义抽象类或接口
- 子类继承父类重写部分算法框架不同的代码，实现代码复用
优势：
- 你可仅允许客户端重写一个大型算法中的特定部分， 使得算法其他部分修改对其所造成的影响减小。
- 你可将重复代码提取到一个超类中。
劣势：
- 部分客户端可能会受到算法框架的限制。
- 通过子类抑制默认步骤实现可能会导致违反
里氏替换原则。 - 模板方法中的步骤越多， 其维护工作就可能会越困难。
下面是实现代码：
package main
import "fmt"
type parseInterface interface {
open()
read()
analyze()
report()
close()
}
func parse(p parseInterface) {
p.open()
p.read()
p.analyze()
p.report()
p.close()
}
type parseFile struct{}
func (p *parseFile) open() {
fmt.Println("default open")
}
func (p *parseFile) read() {
fmt.Println("default read")
}
func (p *parseFile) analyze() {
fmt.Println("default analyze")
}
func (p *parseFile) report() {
fmt.Println("default report")
}
func (p *parseFile) close() {
fmt.Println("default close")
}
func (p *parseFile) parse() {
parse(p)
}
type parsePDF struct{
parseFile
}
func (p *parsePDF) open() {
fmt.Println("PDF open")
}
func (p *parsePDF) read() {
fmt.Println("PDF read")
}
func (p *parsePDF) close() {
fmt.Println("PDF close")
}
func (p *parsePDF) parse() {
parse(p)
}
func main() {
pdf := parsePDF{}
pdf.parse()
}
输出：
PDF open
PDF read
default analyze
default report
PDF close
