模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构的情况下，重新定义算法中的某些步骤
确定了步骤的执行顺序，单某些步骤因环境或人等因素具体实现是未知的
请客吃饭【点菜->吃东西->结账】，每个人点菜不一样，吃东西不一样，结账也不一样从某地到某地【起点->出行方式->终点】起点和终点不一一样，但是每个人出行方式是不一样的
Go没有封装、继承、多态这些概念，但同样通过别的方式可以实现这些特性
| 编号 | 角色 | 描述 |
|---|---|---|
| 1 | 抽象父类（AbstractClass） | 实现了模板方法，定义了算法的骨架 |
| 2 | 具体类（ConcreteClass) | 实现抽象类中的抽象方法，即不同的对象的具体实现细节 |
优点：
缺点：
每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大
使用场景：
有多个子类共有的方法，且逻辑相同
重要的、复杂的方法，可以考虑作为模板方法
package main
import "fmt"
/*出行方式接口*/
type Itravel interface {
Starting() //起点
Travel() //出行方式
End() //终点
}
//定义父类
type Persion struct {
Name string //姓名
Itravel Itravel //出行方式接口
}
func (persion *Persion) SetName(name string) {
persion.Name = name
}
func (persion Persion) Starting() {
persion.Itravel.Starting()
}
func (persion Persion) Travel() {
persion.Itravel.Travel()
}
func (persion Persion) End() {
persion.Itravel.End()
}
//算法骨架
func (persion Persion) Start() {
if persion.Itravel == nil {
fmt.Println("Itravel is nil")
return
}
fmt.Printf("%s", persion.Name)
persion.Starting()
persion.Travel()
persion.End()
fmt.Println("\n")
}
//具体类：张三
type ZhangSan struct {
Persion //匿名字段实现继承
}
func NewZhangSan() *ZhangSan {
c := new(ZhangSan)
c.Persion = Persion{Itravel: c}
return c
}
func (_ ZhangSan) Starting() {
fmt.Printf("从%s出发", "北京")
}
func (_ ZhangSan) Travel() {
fmt.Printf(" %s", "火车")
}
func (_ ZhangSan) End() {
fmt.Printf(" %s", "到达上海")
}
//具体类：李四
type LiSi struct {
Persion
}
func (_ LiSi) Starting() {
fmt.Printf("从%s出发", "广州")
}
func (_ LiSi) Travel() {
fmt.Printf(" %s", "坐飞机")
}
func (_ LiSi) End() {
fmt.Printf(" %s", "到达重庆")
}
func main() {
//张三
zhangsan := NewZhangSan()
zhangsan.SetName("张三")
zhangsan.Start()
persion := &Persion{}
persion.SetName("张三")
persion.Itravel = ZhangSan{}
persion.Start()
//李四
persion.SetName("李四")
persion.Itravel = &LiSi{}
persion.Start()
lisi := LiSi{}
lisi.Itravel = lisi
lisi.SetName("李四")
lisi.Start()
}
