go语言通过结构体嵌入实现类型组合，当外部结构体和嵌入结构体拥有同名方法时，外部结构体的方法会“覆盖”嵌入结构体的方法。本文将深入探讨go语言中这种方法覆盖机制，并详细介绍如何在发生覆盖后，通过显式访问嵌入结构体实例来调用被覆盖的原始方法，通过实例代码展示其具体实现。
Go语言的组合与嵌入式结构体
Go语言不同于传统面向对象语言的继承机制，它通过“组合”而非“继承”来实现代码复用和类型扩展。其中，结构体嵌入（Struct Embedding）是Go语言实现组合的一种强大方式。当一个结构体A嵌入另一个结构体B时，结构体A会自动“提升”结构体B的所有字段和方法，使其可以直接通过结构体A的实例进行访问，仿佛这些字段和方法是结构体A自身定义的一样。
例如，定义一个Human结构体和一个Employee结构体，其中Employee嵌入Human：
package main
import "fmt"
type Human struct {
name string
age int
phone string
}
type Employee struct {
Human // 嵌入 Human 结构体
company string
}
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s, you can call me on %s\n", h.name, h.phone)
}在这个例子中，Employee类型拥有Human的所有字段（name, age, phone）和方法（SayHi）。我们可以直接通过Employee的实例来调用SayHi方法，Go会自动将调用转发给嵌入的Human类型。
方法覆盖（Method Shadowing）机制
当嵌入结构体和外部结构体都定义了同名方法时，Go语言会采用一种“方法覆盖”（Method Shadowing）的机制。具体来说，外部结构体（即包含嵌入结构体的结构体）自身定义的方法会优先于嵌入结构体的方法被调用。这并不是传统意义上的多态或方法重载，而更像是命名冲突解决：外部类型的方法“遮蔽”了嵌入类型的方法。
立即学习“go语言免费学习笔记（深入）”；
让我们在Employee结构体上也定义一个SayHi方法：
func (e *Employee) SayHi() {
fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name, e.company, e.phone)
}现在，Employee类型有了自己的SayHi方法。当我们创建一个Employee实例并调用SayHi()时，Go语言的运行时会优先调用Employee类型自身定义的SayHi方法，而不是其嵌入的Human类型的SayHi方法。
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
显式调用被覆盖的嵌入式方法
尽管外部结构体的方法会覆盖嵌入结构体的同名方法，Go语言依然提供了一种机制来显式地调用被覆盖的嵌入结构体的原始方法。实现方式非常直观：通过访问嵌入结构体的实例字段来调用其方法。
在Go语言中，当一个结构体嵌入另一个结构体时，被嵌入的结构体实际上成为了一个匿名字段。这个匿名字段的名称就是其类型名称（不包括包名）。因此，我们可以通过外部结构体实例.嵌入结构体类型名.方法名()的格式来访问被覆盖的方法。
以下是完整的示例代码，展示了如何创建Employee实例，并分别调用其自身方法和被覆盖的Human方法：
package main
import "fmt"
// Human 结构体定义
type Human struct {
name string
age int
phone string
}
// Employee 结构体定义，嵌入 Human
type Employee struct {
Human // 嵌入 Human 结构体
company string
}
// Human 类型的 SayHi 方法
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s, you can call me on %s\n", h.name, h.phone)
}
// Employee 类型的 SayHi 方法，覆盖 Human 的 SayHi
func (e *Employee) SayHi() {
fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name, e.company, e.phone)
}
func main() {
// 创建 Employee 实例
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
// 调用 Employee 自身的 SayHi 方法（被覆盖的方法）
fmt.Print("调用 Employee.SayHi(): ")
sam.SayHi()
// 显式调用 Human 嵌入结构体的 SayHi 方法
fmt.Print("调用 sam.Human.SayHi(): ")
sam.Human.SayHi()
}运行上述代码，将得到如下输出：
调用 Employee.SayHi(): Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX 调用 sam.Human.SayHi(): Hi, I am Sam, you can call me on 111-888-XXXX
从输出可以看出，sam.SayHi()调用的是Employee类型定义的SayHi方法，而sam.Human.SayHi()则成功调用了Human类型定义的SayHi方法。
注意事项与最佳实践
- 理解组合而非继承： Go语言的嵌入式结构体是一种组合机制，它模拟了某些继承的特性，但本质上仍是组合。不应将其与传统面向对象语言的继承混淆。
- 方法名称冲突： 当外部结构体和嵌入结构体存在同名方法时，外部方法总是优先。这种行为是可预测的，但也可能导致意外，因此在设计时应谨慎考虑方法命名。
- 显式访问的场景： 显式调用被覆盖的嵌入式方法在某些特定场景下非常有用，例如当外部类型需要对嵌入类型的行为进行扩展或修改，但同时又需要保留访问原始行为的能力时。然而，如果过度依赖这种机制，可能意味着设计上存在改进空间，例如考虑使用接口或为不同行为定义不同的方法名。
- 可读性： sam.Human.SayHi()的语法清晰地表明了你正在调用哪个具体类型的方法，这有助于提高代码的可读性。
总结
Go语言通过结构体嵌入实现了强大的类型组合能力。当外部结构体的方法覆盖了嵌入结构体的同名方法时，Go语言允许开发者通过外部实例.嵌入类型名.方法名()的方式，显式地访问并调用被覆盖的嵌入结构体的原始方法。理解这一机制对于编写灵活且可维护的Go代码至关重要，尤其是在处理复杂类型组合时。正确地运用方法覆盖和显式调用技巧，能够帮助开发者更好地利用Go语言的特性来构建健壮的应用程序。
