首先，我想说我的问题不是基于特定问题，而是基于对 go 编译器为何以某种方式运行的潜在讨论。我希望特定语言的潜在专家（或至少具有丰富经验的人）可以解释这种潜在的奇怪行为。
此外，标题可能有点令人困惑，因为我不确定如何在没有示例和更详细的故事的情况下用一句话（一个问题）进行解释。
为了清楚地解释标题中问题的含义，让我从一个符合我预期的情况开始。
package main
import (
"fmt"
"reflect"
)
type mytype1 struct {
mytype2
}
type mytype2 struct {
}
func (mytype2) function1() {
}
func (*mytype2) function2() {
}
func main() {
t1 := reflect.typeof(mytype1{})
t2 := reflect.typeof(&mytype1{})
fmt.println(t1, "has", t1.nummethod(), "methods:")
for i := 0; i < t1.nummethod(); i++ {
fmt.print(" method#", i, ": ", t1.method(i).name, "n")
}
fmt.println(t2, "has", t2.nummethod(), "methods:")
for i := 0; i < t2.nummethod(); i++ {
fmt.print(" method#", i, ": ", t2.method(i).name, "n")
}
}
当类型嵌入基于“类型”（不是正确的名称，但我们这样称呼它）时，一切都会按我的预期运行。结构 mytype1 有一个 mytype2 嵌入字段（“type”嵌入字段），因此类型 mytype1 在其方法集中将具有方法 (mytype1)function1() ，类型 *mytype1 将具有方法 (*my类型1)其方法集中有function1()和(*mytype1)function2()。因此，每种类型（mytype1 和 *mytype1）都会获得其相应的方法。 *mytype1 将获取方法 (*mytype1)function1() 因为它隐式源自 (mytype1)function1()。所以，正如我之前所说，一切都在意料之中。为了证明这一点，我还使用了标准的“reflect”包并得到了以下打印输出：
main.mytype1 has 1 methods: method#0: function1 *main.mytype1 has 2 methods: method#0: function1 method#1: function2
当我用“指针类型”嵌入字段替换“类型”嵌入字段时，会发生奇怪的行为（mytype1 现在有 *mytype2 而不是 mytype2）。所以代码如下所示：
package main
import (
"fmt"
"reflect"
)
type mytype1 struct {
*mytype2
}
type mytype2 struct {
}
func (mytype2) function1() {
}
func (*mytype2) function2() {
}
func main() {
t1 := reflect.typeof(mytype1{})
t2 := reflect.typeof(&mytype1{})
fmt.println(t1, "has", t1.nummethod(), "methods:")
for i := 0; i < t1.nummethod(); i++ {
fmt.print(" method#", i, ": ", t1.method(i).name, "n")
}
fmt.println(t2, "has", t2.nummethod(), "methods:")
for i := 0; i < t2.nummethod(); i++ {
fmt.print(" method#", i, ": ", t2.method(i).name, "n")
}
}
现在问题的症结到底是什么？打印的内容是：
main.MyType1 has 2 methods: method#0: Function1 method#1: Function2 *main.MyType1 has 2 methods: method#0: Function1 method#1: Function2
因此，mytype1 也有方法 (mytype1)function2()，即使它没有声明为 mytype2 类型的值接收器方法。
有人对为什么会发生这种情况有任何合理的解释吗？
简单的解释是：如果类型 a 嵌入类型 b，则类型 a 获取类型 b 的所有方法。
在第一个示例中，mytype2 嵌入到 mytype1 中，并且 mytype2 有一个函数 function1，因此 mytype1 也获取 function1。
在第二个示例中，*mytype2 有两个函数，function1 和 function2，因此 mytype1 具有这两个函数。
这里重要的一点是，使用 a 类型的指针接收器定义的方法仅为 *a 定义，而不是为 a 定义。这样做的原因是为接口提供正确的语义。
假设您有一个界面：
type myintf interface {
function2()
}
如果有一个函数：
func f(m MyIntf) {
m.Function2()
}
那么此属性会阻止您将 mytype1 传递给 f，因为如果允许，则 f 通过调用 function2 对该对象所做的修改将会丢失。您只能传递 mytype2 或第二个 mytype1 实现，在这种情况下，对 m 所做的任何修改都将反映在传递的值实例上。
