• 类型内嵌
    • 类型内嵌语法
    • 哪些类型可以被内嵌？
    • 类型内嵌的意义是什么？
    • 当一个结构体类型内嵌了另一个类型，此结构体类型是否获取了被内嵌类型的字段和方法？
    • 选择器的缩写形式
    • 选择器遮挡和碰撞
    • 为内嵌了其它类型的结构体类型声明的隐式方法
    • 接口类型内嵌接口类型
    • 一个有趣的类型内嵌的例子

    类型内嵌

    从结构体一文中，我们得知一个结构体类型可以拥有若干字段。每个字段由一个字段名和一个字段类型组成。事实上，有时，一个字段可以仅由一个字段类型组成。这样的字段声明方式称为类型内嵌（type embedding）。

    此篇文章将解释类型内嵌的目的和各种和类型内嵌相关的细节。

    类型内嵌语法

    下面是一个使用了类型内嵌的例子：

    1. package main
    3. import "net/http"
    5. func main() {
    6.     type P = *bool
    7.     type M = map[int]int
    8.     var x struct {
    9.         string // 一个定义的非指针类型
    10.         error  // 一个定义的接口类型
    11.         *int   // 一个非定义指针类型
    12.         P      // 一个非定义指针类型的别名
    13.         M      // 一个非定义类型的别名
    15.         http.Header // 一个定义的映射类型
    16.     }
    17.     x.string = "Go"
    18.     x.error = nil
    19.     x.int = new(int)
    20.     x.P = new(bool)
    21.     x.M = make(M)
    22.     x.Header = http.Header{}
    23. }

    在上面这个例子中，有六个类型被内嵌在了一个结构体类型中。每个类型内嵌形成了一个内嵌字段（embedded field）。

    因为历史原因，内嵌字段有时也称为匿名字段。但是，事实上，每个内嵌字段有一个（隐式的）名字。此字段的非限定（unqualified）类型名即为此字段的名称。比如，上例中的六个内嵌字段的名称分别为string、error、int、P、M和Header。

    哪些类型可以被内嵌？

    当前的Go白皮书（1.13）规定：

    An embedded field must be specified as a type name T or as a pointer to a non-interface type name *T, and T itself may not be a pointer type.

    翻译过来：

    一个内嵌字段必须被声明为形式T或者一个基类型为非接口类型的指针类型*T，其中T为一个类型名但是T不能表示一个指针类型。

    此规则描述在Go 1.9之前是精确的。但是随着从Go 1.9引入的自定义类型别名概念，此描述有些过时和不太准确了。比如，此描述没有包括上一节的例子中的P内嵌字段的情形。 这里，本文试图使用一个更精确的描述：

    • 一个类型名T只有在它既不表示一个定义的指针类型也不表示一个基类型为指针类型或者接口类型的指针类型的情况下在可以被用作内嵌字段。
    • 一个指针类型T只有在T为一个类型名并且T既不表示一个指针类型也不表示一个接口类型的时候才能被用作内嵌字段。<!—这里，本文试图使用一个更精确的描述：
      • 一个类型名T只有在它不表示一个基类型为指针类型或者接口类型的指针类型的情况下在可以被用作内嵌字段。
      • 一个指针类型T只有在T为一个类型名并且T既不表示一个指针类型也不表示一个接口类型的时候才能被用作内嵌字段。
      或者，我们也可以对Go白皮书中的描述略加修改：
      一个内嵌字段必须被声明为形式T或者T，其中T为一个类型名并且T和T不能表示基类型为指针类型或者接口类型的指针类型。
      —>下面列出了一些可以被或不可以被内嵌的类型或别名：
    1. type Encoder interface {Encode([]byte) []byte}
    2. type Person struct {name string; age int}
    3. type Alias = struct {name string; age int}
    4. type AliasPtr = *struct {name string; age int}
    5. type IntPtr *int
    6. type AliasPP = *IntPtr
    8. // 这些类型或别名都可以被内嵌。
    9. Encoder
    10. Person
    11. *Person
    12. Alias
    13. *Alias
    14. AliasPtr
    15. int
    16. *int
    18. // 这些类型或别名都不能被内嵌。
    19. AliasPP          // 基类型为一个指针类型
    20. *Encoder         // 基类型为一个接口类型
    21. *AliasPtr        // 基类型为一个指针类型
    22. IntPtr           // 定义的指针类型
    23. *IntPtr          // 基类型为一个指针类型
    24. *chan int        // 基类型为一个非定义类型
    25. struct {age int} // 非定义非指针类型
    26. map[string]int   // 非定义非指针类型
    27. []int64          // 非定义非指针类型
    28. func()           // 非定义非指针类型

    一个结构体类型中不允许有两个同名字段，此规则对匿名字段同样适用。根据上述内嵌字段的隐含名称规则，一个非定义指针类型不能和它的基类型同时内嵌在同一个结构体类型中。比如，int和*int类型不能同时内嵌在同一个结构体类型中。

    一个结构体类型不能内嵌（无论间接还是直接）它自己。

    一般说来，只有内嵌含有字段或者拥有方法的类型才有意义（后续几节将阐述原因），尽管很多既没有字段也没有方法的类型也可以被内嵌。

    类型内嵌的意义是什么？

    类型内嵌的主要目的是为了将被内嵌类型的功能扩展到内嵌它的结构体类型中，从而我们不必再为此结构体类型重复实现一下被内嵌类型的功能。 很多其它流行面向对象的编程语言都是用继承来实现上述目的。两种实现方式有它们各自的利弊。这里，此篇文章将不讨论哪种方式更好一些，我们只需知道Go选择了类型内嵌这种方式。这两种方式有一个很大的不同点：

    • 如果类型T继承了另外一个类型，则类型T获取了另外一个类型的能力。同时，一个T类型的值也可以被当作另外一个类型的值来使用。
    • 如果一个类型T内嵌了另外一个类型，则另外一个类型变成了类型T的一部分。类型T获取了另外一个类型的能力，但是T类型的任何值都不能被当作另外一个类型的值来使用。下面是一个展示了如何通过类型内嵌来扩展类型功能的例子：
    1. package main
    3. import "fmt"
    5. type Person struct {
    6.     Name string
    7.     Age  int
    8. }
    9. func (p Person) PrintName() {
    10.     fmt.Println("Name:", p.Name)
    11. }
    12. func (p *Person) SetAge(age int) {
    13.     p.Age = age
    14. }
    16. type Singer struct {
    17.     Person // 通过内嵌Person类型来扩展之
    18.     works  []string
    19. }
    21. func main() {
    22.     var gaga = Singer{Person: Person{"Gaga", 30}}
    23.     gaga.PrintName() // Name: Gaga
    24.     gaga.Name = "Lady Gaga"
    25.     (&gaga).SetAge(31)
    26.     (&gaga).PrintName()   // Name: Lady Gaga
    27.     fmt.Println(gaga.Age) // 31
    28. }

    从上例中，当类型Singer内嵌了类型Person之后，看上去类型Singer获取了类型Person所有的字段和方法，并且类型Singer获取了类型Person所有的方法。此结论是否正确？随后几节将给出答案。 注意，类型Singer的一个值不能被当作Person类型的值用。下面的代码编译不通过：

    1. var gaga = Singer{}
    2. var _ Person = gaga

    当一个结构体类型内嵌了另一个类型，此结构体类型是否获取了被内嵌类型的字段和方法？

    下面这个程序使用反射列出了上一节的例子中的Singer类型的字段和方法，以及*Singer类型的方法。

    1. package main
    3. import (
    4.     "fmt"
    5.     "reflect"
    6. )
    8. ... // 为节省篇幅，上一个例子中声明的类型在这里省略了。
    10. func main() {
    11.     t := reflect.TypeOf(Singer{}) // the Singer type
    12.     fmt.Println(t, "has", t.NumField(), "fields:")
    13.     for i := 0; i < t.NumField(); i++ {
    14.         fmt.Print(" field#", i, ": ", t.Field(i).Name, "\n")
    15.     }
    16.     fmt.Println(t, "has", t.NumMethod(), "methods:")
    17.     for i := 0; i < t.NumMethod(); i++ {
    18.         fmt.Print(" method#", i, ": ", t.Method(i).Name, "\n")
    19.     }
    21.     pt := reflect.TypeOf(&Singer{}) // the *Singer type
    22.     fmt.Println(pt, "has", pt.NumMethod(), "methods:")
    23.     for i := 0; i < pt.NumMethod(); i++ {
    24.         fmt.Print(" method#", i, ": ", pt.Method(i).Name, "\n")
    25.     }
    26. }

    输出结果：

    1. main.Singer has 2 fields:
    2.  field#0: Person
    3.  field#1: works
    4. main.Singer has 1 methods:
    5.  method#0: PrintName
    6. *main.Singer has 2 methods:
    7.  method#0: PrintName
    8.  method#1: SetAge

    从此输出结果中，我们可以看出类型Singer确实拥有一个PrintName方法，以及类型*Singer确实拥有两个方法：PrintName和SetAge。但是类型Singer并不拥有一个Name字段。那么为什么选择器表达式gaga.Name是合法的呢？毕竟gaga是Singer类型的一个值。请阅读下一节以获取原因。

    选择器的缩写形式

    从前面的结构体和方法两篇文章中，我们得知，对于一个值x，x.y称为一个选择器，其中y可以是一个字段名或者方法名。如果y是一个字段名，那么x必须为一个结构体值或者结构体指针值。一个选择器是一个表达式，它表示着一个值。如果选择器x.y表示一个字段，此字段也可能拥有自己的字段（如果此字段的类型为另一个结构体类型）和方法，比如x.y.z，其中z可以是一个字段名，也可是一个方法名。

    在Go中，（不考虑下面将要介绍的选择器碰撞和遮挡），如果一个选择器中的中部某项对应着一个内嵌字段，则此项可被省略掉。这是为什么内嵌字段又被称为匿名字段的原因。

    一个例子：

    1. package main
    3. type A struct {
    4.     x int
    5. }
    6. func (a A) MethodA() {}
    8. type B struct {
    9.     A
    10. }
    11. type C struct {
    12.     B
    13. }
    15. func main() {
    16.     var c C
    18.     // 下面的赋值语句中的选择器都是相互等价的。
    19.     _ = c.B.A.x
    20.     _ = c.B.x
    21.     _ = c.A.x
    22.     _ = c.x // x被称为类型C的一个提升字段
    24.     // 这下面的几个方法调用都是互相等价的。
    25.     c.B.A.MethodA()
    26.     c.B.MethodA()
    27.     c.A.MethodA()
    28.     c.MethodA()
    29. }

    这就是为什么在上一节的例子中选择器表达式gaga.Name是合法的原因，因为它只不过是gaga.Person.Name的一个缩写形式。Name被称为类型Singer的提升字段（promoted field）。 因为任何内嵌其它类型的类型必然是结构体类型，并且结构体一文中已经了我们可以通过一个可寻址的结构体值的指针选择此结构体的字段，所以下面的代码也是合法的：

    1. func main() {
    2.     var c C
    3.     pc = &c
    5.     // 这几行等价。
    6.     fmt.Println(pc.B.A.x)
    7.     fmt.Println(pc.B.x)
    8.     fmt.Println(pc.A.x)
    9.     fmt.Println(pc.x)
    11.     // 这几行等价。
    12.     pc.B.A.MethodA()
    13.     pc.B.MethodA()
    14.     pc.A.MethodA()
    15.     pc.MethodA()
    16. }

    类似的，选择器gaga.PrintName可以被看作是gaga.Person.PrintName的缩写形式。但是，我们也可以不把它看作是一个缩写。毕竟，类型Singer确实拥有一个PrintName方法，尽管此方法是被隐式声明的（请阅读下下节以获得详情）。同样的原因，选择器(&gaga).PrintName和(&gaga).SetAge可以看作（也可以不看作）是(&gaga.Person).PrintName和(&gaga.Person).SetAge的缩写。

    注意：我们也可以使用选择器gaga.SetAge，但是只有在gaga是一个可寻址的类型为Singer的值的情况下。它只不过是(&gaga).SetAge的一个语法糖。

    在上面的例子中，c.B.A.x称为选择器表达式c.x、c.B.x和c.A.x的完整形式。类似的，c.B.A.MethodA可以称为c.MethodA、c.B.MethodA和c.A.MethodA的完整形式。

    如果一个选择器的完整形式中的所有中部项均对应着一个内嵌字段，则中部项的数量称为此选择器的深度。比如，上面的例子中的选择器c.MethodA的深度为2，因为此选择器的完整形式为c.B.A.MethodA，并且B和A都对应着一个内嵌字段。

    选择器遮挡和碰撞

    一个值x（这里我们总认为它是可寻址的）可能同时拥有多个最后一项相同的选择器，并且这些选择器的中间项均对应着一个内嵌字段。对于这种情形（假设最后一项为y）：

    • 只有深度最浅的一个完整形式的选择器（并且最浅者只有一个）可以被缩写为x.y。换句话说，x.y表示深度最浅的一个选择器。其它完整形式的选择器被此最浅者所遮挡（压制）。
    • 如果有多个完整形式的选择器同时拥有最浅深度，则任何完整形式的选择器都不能被缩写为x.y。我们称这些同时拥有最浅深度的完整形式的选择器发生了碰撞。 如果一个方法选择器被另一个方法选择器所遮挡，并且它们对应的方法原型是一致的，那么我们可以说第一个方法被第二个覆盖（overridden）了。 举个例子，假设A、B和C为三个定义类型：
    1. type A struct {
    2.     x string
    3. }
    4. func (A) y(int) bool {
    5.     return false
    6. }
    8. type B struct {
    9.     y bool
    10. }
    11. func (B) x(string) {}
    13. type C struct {
    14.     B
    15. }

    下面这段代码编译不通过，原因是选择器v1.A.x和v1.B.x发生了碰撞，结果导致它们都不能被缩写为v1.x。同样的情况发生在选择器v1.A.y和v1.B.y身上。

    1. var v1 struct {
    2.     A
    3.     B
    4. }
    6. func f1() {
    7.     _ = v1.x
    8.     _ = v1.y
    9. }

    下面的代码编译没问题。选择器v2.C.B.x被另一个选择器v2.A.x遮挡了，所以v2.x实际上是选择器v2.A.x的缩写形式。因为同样的原因，v2.y是选择器v2.A.y（而不是选择器v2.C.B.y）的缩写形式。

    1. var v2 struct {
    2.     A
    3.     C
    4. }
    6. func f2() {
    7.     fmt.Printf("%T \n", v2.x) // string
    8.     fmt.Printf("%T \n", v2.y) // func(int) bool
    9. }

    为内嵌了其它类型的结构体类型声明的隐式方法

    上面已经提到过，类型Singer和Singer都有一个PrintName方法，并且类型Singer还有一个SetAge方法。但是，我们从没有为这两个类型声明过这几个方法。这几个方法从哪来的呢？ 事实上，假设结构体类型S内嵌了一个类型T，并且此内嵌是合法的，

    • 对内嵌类型T的每一个方法，如果此方法对应的选择器既不和其它选择器碰撞也未被其它选择器遮挡，则编译器将会隐式地为结构体类型S声明一个同样原型的方法。继而，编译器也将为指针类型*S隐式声明一个相应的方法。
    • 对类型T的每一个方法，如果此方法对应的选择器既不和其它选择器碰撞也未被其它选择器遮挡，则编译器将会隐式地为类型S声明一个同样原型的方法。 上述事实在类型T不可内嵌的情况下（即T是一个指针或者接口类型时）仍存在。如果即T是一个指针或者接口类型时，则类型T的方法集为空。 简单说来，
    • 类型struct{T}和*struct{T}将获取类型T的所有方法。
    • 类型struct{T}、struct{T}和struct{T}将获取类型T的所有方法。下面展示了编译器为类型Singer和Singer隐式声明的三个方法：
    1. func (s Singer) PrintName() {
    2.     s.Person.PrintName()
    3. }
    5. func (s *Singer) PrintName() {
    6.     (*s).Person.PrintName()
    7. }
    9. func (s *Singer) SetAge(age int) {
    10.     (&s.Person).SetAge(age) // <=> (&((*s).Person)).SetAge(age)
    11. }

    从方法一文中，我们得知我们不能为非定义的结构体类型（和基类型为非定义结构体类型的指针类型）声明方法。但是，通过类型内嵌，这样的类型也可以拥有方法。 下面是另一个证明了类型内嵌导致了一些方法被隐式声明的例子：

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. type F func(int) bool
    7. func (f F) Validate(n int) bool {
    8.     return f(n)
    9. }
    10. func (f *F) Modify(f2 F) {
    11.     *f = f2
    12. }
    14. type B bool
    15. func (b B) IsTrue() bool {
    16.     return bool(b)
    17. }
    18. func (pb *B) Invert() {
    19.     *pb = !*pb
    20. }
    22. type I interface {
    23.     Load()
    24.     Save()
    25. }
    27. func PrintTypeMethods(t reflect.Type) {
    28.     fmt.Println(t, "has", t.NumMethod(), "methods:")
    29.     for i := 0; i < t.NumMethod(); i++ {
    30.         fmt.Print(" method#", i, ": ", t.Method(i).Name, "\n")
    31.     }
    32. }
    34. func main() {
    35.     var s struct {
    36.         F
    37.         *B
    38.         I
    39.     }
    41.     PrintTypeMethods(reflect.TypeOf(s))
    42.     fmt.Println()
    43.     PrintTypeMethods(reflect.TypeOf(&s))
    44. }

    输出结果：

    1. struct { main.F; *main.B; main.I } has 5 methods:
    2.  method#0: Invert
    3.  method#1: IsTrue
    4.  method#2: Load
    5.  method#3: Save
    6.  method#4: Validate
    8. *struct { main.F; *main.B; main.I } has 6 methods:
    9.  method#0: Invert
    10.  method#1: IsTrue
    11.  method#2: Load
    12.  method#3: Modify
    13.  method#4: Save
    14.  method#5: Validate

    如果一个结构体类型内嵌了一个实现了一个接口类型的类型（此内嵌类型可以是此接口类型自己），则一般说来，此结构体类型也实现了此接口类型，除非发生了选择器碰撞和遮挡。比如，上例中的结构体类型和以它为基类型的指针类型均实现了接口类型I。 请注意：一个类型将只会获取它（直接或者间接）内嵌了的类型的方法。比如，在下面的例子中，

    • 类型Age没有方法，因为它没有内嵌任何类型。
    • 类型X有两个方法：IsOdd和Double。其中IsOdd方法是通过内嵌类型MyInt而得来的。
    • 类型Y没有方法，因为它所内嵌的类型Age没有方法。
    • 类型Z只有一个方法：IsOdd。此方法是通过内嵌类型MyInt而得来的。它没有获取到类型X的Double方法，因为它并没有内嵌类型X。
    1. type MyInt int
    2. func (mi MyInt) IsOdd() bool {
    3.     return mi%2 == 1
    4. }
    6. type Age MyInt
    8. type X struct {
    9.     MyInt
    10. }
    11. func (x X) Double() MyInt {
    12.     return x.MyInt + x.MyInt
    13. }
    15. type Y struct {
    16.     Age
    17. }
    19. type Z X

    接口类型内嵌接口类型

    不但结构体类型可以内嵌类型，接口类型也可以内嵌类型。但是接口类型只能内嵌接口类型。详情请阅读接口一文。

    一个有趣的类型内嵌的例子

    在本文的最后，让我们来看一个有趣的例子。此例子程序将陷入死循环并会因堆栈溢出而崩溃退出。如果你已经理解了多态和类型内嵌，那么就不难理解为什么此程序将死循环。

    1. package main
    3. type I interface {
    4.     m()
    5. }
    7. type T struct {
    8.     I
    9. }
    11. func main() {
    12.     var t T
    13.     var i = &t
    14.     t.I = i
    15.     i.m() // 将调用t.m()，然后再次调用i.m()，...
    16. }

    Go语言101项目目前同时托管在Github和Gitlab上。欢迎各位在这两个项目中通过提交bug和PR的方式来改进完善Go语言101中的各篇文章。

    本书微信公众号名称为"Go 101"。每个工作日此公众号将尽量发表一篇和Go语言相关的原创短文。各位如果感兴趣，可以搜索关注一下。

    赞赏