Go语言教程：深入浅出理解结构体嵌套与方法重写

介绍#

在Go语言中，结构体（struct）是一个非常重要的数据类型，它允许我们将不同类型的数据组合在一起。通过嵌套结构体和方法重写，我们可以实现更复杂的数据模型和行为。本文将通过一个具体的代码示例，深入浅出地介绍这些概念。

示例代码#

以下是一个完整的Go语言代码示例，展示了如何使用结构体嵌套和方法重写：

1
package main
2

3
import "fmt"
4

5
// 示例1。
6
// AnimalCategory 代表动物分类学中的基本分类法。
7
type AnimalCategory struct {
8
  kingdom string // 界。
9
  phylum  string // 门。
10
  class   string // 纲。
11
  order   string // 目。
12
  family  string // 科。
13
  genus   string // 属。
14
  species string // 种。
15
}
16

17
func (ac AnimalCategory) String() string {
18
  return fmt.Sprintf("%s%s%s%s%s%s%s",
19
    ac.kingdom, ac.phylum, ac.class, ac.order,
20
    ac.family, ac.genus, ac.species)
21
}
22

23
// 示例2。
24
type Animal struct {
25
  scientificName string // 学名。
26
  AnimalCategory        // 动物基本分类。
27
}
28

29
// 该方法会"屏蔽"掉嵌入字段中的同名方法。
30
func (a Animal) String() string {
31
  return fmt.Sprintf("%s (category: %s)",
32
    a.scientificName, a.AnimalCategory)
33
}
34

35
// 示例3。
36
type Cat struct {
37
  name string
38
  Animal
39
}
40

41
// 该方法会"屏蔽"掉嵌入字段中的同名方法。
42
func (cat Cat) String() string {
43
  return fmt.Sprintf("%s (category1: %s, name: %q)",
44
    cat.scientificName, cat.Animal.AnimalCategory, cat.name)
45
}
46

47
func main() {
48
  // 示例1。
49
  category := AnimalCategory{species: "cat"}
50
  fmt.Printf("The animal category: %s\\n", category)
51

52
  // 示例2。
53
  animal := Animal{
54
    scientificName: "American Shorthair",
55
    AnimalCategory: category,
56
  }
57
  fmt.Printf("The animal: %s\\n", animal)
58

59
  // 示例3。
60
  cat := Cat{
61
    name:   "little pig",
62
    Animal: animal,
63
  }
64
  fmt.Printf("The cat: %s\\n", cat)
65
}

代码解析#

示例1：基本结构体#

首先，我们定义了一个 AnimalCategory 结构体，用于表示动物分类学中的基本分类法。这个结构体包含了多个字段，如 kingdom（界）、phylum（门）、class（纲）等。

1
type AnimalCategory struct {
2
  kingdom string // 界。
3
  phylum  string // 门。
4
  class   string // 纲。
5
  order   string // 目。
6
  family  string // 科。
7
  genus   string // 属。
8
  species string // 种。
9
}

我们还为 AnimalCategory 结构体定义了一个 String 方法，用于返回该结构体的字符串表示。

1
func (ac AnimalCategory) String() string {
2
  return fmt.Sprintf("%s%s%s%s%s%s%s",
3
    ac.kingdom, ac.phylum, ac.class, ac.order,
4
    ac.family, ac.genus, ac.species)
5
}

示例2：嵌套结构体#

接下来，我们定义了一个 Animal 结构体，它嵌套了 AnimalCategory 结构体，并添加了一个 scientificName 字段。

1
type Animal struct {
2
  scientificName string // 学名。
3
  AnimalCategory        // 动物基本分类。
4
}

同样，我们为 Animal 结构体定义了一个 String 方法，这个方法会“屏蔽”掉嵌入字段中的同名方法。

1
func (a Animal) String() string {
2
  return fmt.Sprintf("%s (category: %s)",
3
    a.scientificName, a.AnimalCategory)
4
}

示例3：进一步嵌套#

最后，我们定义了一个 Cat 结构体，它嵌套了 Animal 结构体，并添加了一个 name 字段。

1
type Cat struct {
2
  name string
3
  Animal
4
}

同样，我们为 Cat 结构体定义了一个 String 方法，这个方法会“屏蔽”掉嵌入字段中的同名方法。

1
func (cat Cat) String() string {
2
  return fmt.Sprintf("%s (category1: %s, name: %q)",
3
    cat.scientificName, cat.Animal.AnimalCategory, cat.name)
4
}

运行结果#

在 main 函数中，我们创建了 AnimalCategory、Animal 和 Cat 的实例，并打印它们的字符串表示。

1
func main() {
2
  // 示例1。
3
  category := AnimalCategory{species: "cat"}
4
  fmt.Printf("The animal category: %s\\n", category)
5

6
  // 示例2。
7
  animal := Animal{
8
    scientificName: "American Shorthair",
9
    AnimalCategory: category,
10
  }
11
  fmt.Printf("The animal: %s\\n", animal)
12

13
  // 示例3。
14
  cat := Cat{
15
    name:   "little pig",
16
    Animal: animal,
17
  }
18
  fmt.Printf("The cat: %s\\n", cat)
19
}

运行结果如下：

1
The animal category: cat
2
The animal: American Shorthair (category: cat)
3
The cat: American Shorthair (category1: cat, name: "little pig")

总结#

通过这个示例，我们展示了如何在Go语言中使用结构体嵌套和方法重写。结构体嵌套使得我们可以创建更复杂的数据模型，而方法重写则允许我们为不同的结构体定义特定的行为。这些特性使得Go语言在处理复杂数据结构时非常灵活和强大。