本教程深入探讨go语言中嵌入式类型的方法覆盖机制。当外部结构体定义了与嵌入类型同名的方法时，会发生方法覆盖（shadowing）。文章将通过具体代码示例，详细阐述go如何处理这种情况，并指导开发者如何在方法被覆盖后，显式地调用嵌入类型（“基类”）的原始方法，从而有效利用go的组合特性。
1. Go语言中的嵌入式类型与方法提升
Go语言通过“嵌入式类型”（Embedded Types）实现代码复用和功能组合，而非传统面向对象语言中的继承。当一个结构体（外部结构体）嵌入另一个结构体（嵌入类型）时，外部结构体会自动“提升”（promote）嵌入类型的所有字段和方法。这意味着，我们可以直接通过外部结构体的实例来访问嵌入类型的字段和方法，仿佛它们是外部结构体自身的成员。
为了更好地理解这一机制，请看以下示例：
package main
import "fmt"
// Engine是一个嵌入类型
type Engine struct {
power int
}
// Engine的方法
func (e *Engine) Start() {
fmt.Printf("Engine started with %d HP\n", e.power)
}
// Car是外部结构体，嵌入了Engine类型
type Car struct {
Engine // 嵌入Engine类型，默认字段名为类型名
brand string
}
func main() {
myCar := Car{Engine{150}, "BMW"}
// 通过Car实例直接调用嵌入类型Engine的方法
myCar.Start()
// 通过Car实例直接访问嵌入类型Engine的字段
fmt.Println("Car power:", myCar.power)
}输出结果：
Engine started with 150 HP Car power: 150
在这个例子中，Car结构体嵌入了Engine。Car的实例myCar可以直接调用Engine的Start()方法，并访问Engine的power字段，这正是方法和字段提升的体现。
立即学习“go语言免费学习笔记（深入）”；
2. 方法覆盖（Method Shadowing）
当外部结构体定义了一个与嵌入类型同名的方法时，就会发生方法覆盖，也称为方法遮蔽（shadowing）。在这种情况下，外部结构体自身定义的方法会“优先”被调用，它会遮蔽掉嵌入类型中同名的方法。需要注意的是，这与传统面向对象语言中的方法重载（Method Overloading）不同，Go语言不支持基于参数列表的方法重载。
考虑以下示例，它展示了当Employee结构体和其嵌入的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类型的方法
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
// Employee类型的方法，与Human的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"}
// 调用Employee的SayHi方法，因为它覆盖了Human的SayHi
sam.SayHi()
}在上述代码中，Employee结构体嵌入了Human结构体。两者都定义了SayHi()方法。当通过Employee实例sam调用SayHi()时，Go会优先选择Employee自身定义的方法。
分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。
输出结果：
Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX
3. 显式调用被覆盖的嵌入式方法
尽管外部结构体的方法覆盖了嵌入类型的方法，我们仍然可以显式地调用嵌入类型的原始方法。Go语言允许我们通过嵌入类型的名称（如果未指定字段名，则默认为类型名）来访问嵌入式结构体的实例。
因此，要调用被覆盖的Human的SayHi()方法，只需通过sam.Human.SayHi()即可。这种语法明确指示我们正在访问sam实例中嵌入的Human子结构体，并调用其方法。
修改main函数，同时调用Employee和Human的SayHi()方法：
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)
}
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"}
// 调用 Employee.SayHi()，因为它覆盖了Human的SayHi
sam.SayHi()
// 显式调用 Human.SayHi()，通过嵌入类型名访问
sam.Human.SayHi()
}输出结果：
Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX Hi, I am Sam you can call me on 111-888-XXXX
这个输出清楚地展示了，通过sam.Human，我们能够访问到Employee实例中嵌入的Human结构体实例，进而调用其独有的方法。这与传统OOP语言中的“向下转型”或“基类指针”的概念不同，Go中没有类型层次结构，而是直接通过字段访问嵌入的实例。
4. 总结与注意事项
- 组合优于继承：Go语言推崇组合而非继承，嵌入式类型是实现代码复用和功能扩展的强大机制。它允许开发者通过组合现有类型来构建更复杂的行为。
- 方法覆盖而非重载：Go语言中的同名方法行为是覆盖（shadowing），而非C++/Java等语言中的方法重载（overloading）。Go不支持基于参数签名的方法重载。当外部结构体和嵌入类型有同名方法时，外部结构体的方法会优先被调用。
- 显式访问机制：当嵌入类型的方法被外部结构体的同名方法覆盖时，可以通过OuterStructInstance.EmbeddedType.Method()的语法显式调用嵌入类型的方法。这里的EmbeddedType是嵌入类型本身的名称（如果未给嵌入字段指定显式名称）。
- 代码清晰性：这种显式访问方式提高了代码的清晰度，明确指出了正在调用哪个具体类型的方法，有助于理解程序的行为。
理解Go语言中嵌入式类型的方法覆盖和显式调用机制，对于编写高效、可维护的Go代码至关重要。它允许开发者在享受组合带来的灵活性的同时，也能精确控制方法调用的行为。
