本文探讨go语言中嵌入类型方法被外部结构体“覆盖”（shadowing）时的调用机制。当嵌入结构体的方法被外部结构体同名方法覆盖时，go语言允许通过显式访问嵌入结构体成员来调用其原始方法，从而实现对不同层次方法的精准控制。这种机制是go语言组合优于继承设计理念的体现。
Go语言中的结构体嵌入与方法提升
Go语言通过结构体嵌入（embedding）实现代码复用和组合。当一个结构体嵌入另一个结构体时，被嵌入结构体的字段和方法会被“提升”（promoted）到外部结构体。这意味着外部结构体的实例可以直接访问被嵌入结构体的字段和方法，就像它们是外部结构体自身的成员一样。
例如，如果 Employee 结构体嵌入了 Human 结构体，那么 Employee 的实例 e 可以直接通过 e.name 或 e.SayHi() 来访问 Human 的字段 name 和方法 SayHi。
方法覆盖（Shadowing）机制
Go语言中没有传统意义上的“方法重载”（method overloading，即同名方法参数列表不同），但存在方法覆盖（method shadowing）机制。如果外部结构体定义了一个与被嵌入结构体中同名的方法，那么通过外部结构体实例直接调用该方法时，将优先执行外部结构体自身定义的方法。
这种机制允许外部结构体根据自身特性，提供特定于其行为的实现，同时仍然受益于嵌入带来的代码复用。
立即学习“go语言免费学习笔记（深入）”；
考虑以下示例：
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() {
sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
sam.SayHi() // 调用 Employee 的 SayHi 方法
}在上述代码中，Employee 结构体嵌入了 Human 结构体，并且两者都定义了 SayHi() 方法。当 main 函数中创建 Employee 实例 sam 并调用 sam.SayHi() 时，会执行 Employee 自身定义的 SayHi() 方法，因为该方法覆盖了 Human 的同名方法。
输出结果将是：
十天学会易语言图解教程用图解的方式对易语言的使用方法和操作技巧作了生动、系统的讲解。需要的朋友们可以下载看看吧！全书分十章，分十天讲完。 第一章是介绍易语言的安装，以及运行后的界面。同时介绍一个非常简单的小程序，以帮助用户入门学习。最后介绍编程的输入方法，以及一些初学者会遇到的常见问题。第二章将接触一些具体的问题，如怎样编写一个1+2等于几的程序，并了解变量的概念，变量的有效范围，数据类型等知识。其后，您将跟着本书，编写一个自己的MP3播放器，认识窗口、按钮、编辑框三个常用组件。以认识命令及事件子程序。第
Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX
如何调用被覆盖的嵌入类型方法
在某些场景下，我们可能需要从外部结构体的实例中，调用其被覆盖的嵌入结构体原始方法。Go语言提供了一种直接且明确的方式来解决这个问题：通过显式访问嵌入结构体成员。
由于嵌入结构体在外部结构体中实际上是一个匿名字段（其类型名就是字段名），我们可以通过这个字段名来访问被嵌入结构体本身，进而调用其方法。
语法为：外部结构体实例.嵌入结构体类型名.方法名()。
让我们修改 main 函数来演示如何调用 Human 结构体的原始 SayHi 方法：
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.Println("--- 调用 Employee.SayHi() ---")
sam.SayHi()
// 显式调用嵌入的 Human 结构体的 SayHi 方法
fmt.Println("--- 调用 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() 则明确地通过 sam 实例中的 Human 嵌入字段，调用了 Human 类型上定义的 SayHi 方法。
总结与注意事项
- 方法覆盖而非重载：Go语言中没有传统意义上的方法重载，而是通过方法覆盖（shadowing）来处理嵌入类型与外部类型同名方法的情况。
- 显式访问：要调用被外部结构体方法覆盖的嵌入结构体方法，必须通过 外部实例.嵌入类型名.方法名() 的形式显式地访问嵌入结构体字段。
- 组合优于继承：Go语言的结构体嵌入体现了“组合优于继承”的设计原则。它允许我们通过组合不同的行为来构建复杂类型，而不是通过深层次的继承链。这种机制提供了代码复用和行为定制的灵活性，同时避免了继承带来的复杂性和紧耦合问题。
- 无下转型：Go语言中没有传统面向对象语言中的“下转型”（downcasting），因为Go的设计哲学是组合而非继承，结构体嵌入更像是一种“拥有”关系，而非“是”的关系。因此，不能将 Employee 实例直接视为 Human 实例来调用方法，而是需要通过显式字段访问。
理解Go语言中结构体嵌入、方法提升和方法覆盖的机制，对于编写清晰、可维护且符合Go语言惯例的代码至关重要。
