Go语言教程：深入探究结构体、方法和接口

介绍#

在Go语言中，结构体（struct）、方法和接口是构建复杂数据模型和实现多态行为的基础。本文将通过一个具体的代码示例，深入探究这些概念，并展示如何举一反三地应用它们。

示例代码#

以下是一个完整的Go语言代码示例，展示了如何定义结构体、方法以及接口：

1
package main
2

3
import "fmt"
4

5
type Cat struct {
6
  name           string // 名字。
7
  scientificName string // 学名。
8
  category       string // 动物学基本分类。
9
}
10

11
func New(name, scientificName, category string) Cat {
12
  return Cat{
13
    name:           name,
14
    scientificName: scientificName,
15
    category:       category,
16
  }
17
}
18

19
func (cat *Cat) SetName(name string) {
20
  cat.name = name
21
}
22

23
func (cat Cat) SetNameOfCopy(name string) {
24
  cat.name = name
25
}
26

27
func (cat Cat) Name() string {
28
  return cat.name
29
}
30

31
func (cat Cat) ScientificName() string {
32
  return cat.scientificName
33
}
34

35
func (cat Cat) Category() string {
36
  return cat.category
37
}
38

39
func (cat Cat) String() string {
40
  return fmt.Sprintf("%s (category: %s, name: %q)",
41
    cat.scientificName, cat.category, cat.name)
42
}
43

44
func main() {
45
  cat := New("little pig", "American Shorthair", "cat")
46
  cat.SetName("monster") // (&cat).SetName("monster")
47
  fmt.Printf("The cat: %s\\n", cat)
48

49
  cat.SetNameOfCopy("little pig")
50
  fmt.Printf("The cat: %s\\n", cat)
51

52
  type Pet interface {
53
    SetName(name string)
54
    Name() string
55
    Category() string
56
    ScientificName() string
57
  }
58

59
  _, ok := interface{}(cat).(Pet)
60
  fmt.Printf("Cat implements interface Pet: %v\\n", ok)
61
  _, ok = interface{}(&cat).(Pet)
62
  fmt.Printf("*Cat implements interface Pet: %v\\n", ok)
63
}

代码解析#

定义结构体#

首先，我们定义了一个 Cat 结构体，用于表示猫的基本信息，包括名字、学名和分类。

1
type Cat struct {
2
  name           string // 名字。
3
  scientificName string // 学名。
4
  category       string // 动物学基本分类。
5
}

构造函数#

接下来，我们定义了一个构造函数 New，用于创建 Cat 结构体的实例。

1
func New(name, scientificName, category string) Cat {
2
  return Cat{
3
    name:           name,
4
    scientificName: scientificName,
5
    category:       category,
6
  }
7
}

方法定义#

我们为 Cat 结构体定义了一些方法，包括设置名字、获取名字、获取学名和获取分类的方法。

1
func (cat *Cat) SetName(name string) {
2
  cat.name = name
3
}
4

5
func (cat Cat) SetNameOfCopy(name string) {
6
  cat.name = name
7
}
8

9
func (cat Cat) Name() string {
10
  return cat.name
11
}
12

13
func (cat Cat) ScientificName() string {
14
  return cat.scientificName
15
}
16

17
func (cat Cat) Category() string {
18
  return cat.category
19
}
20

21
func (cat Cat) String() string {
22
  return fmt.Sprintf("%s (category: %s, name: %q)",
23
    cat.scientificName, cat.category, cat.name)
24
}

需要注意的是，SetName 方法接收一个指向 Cat 结构体的指针，这意味着它可以修改原始结构体的内容。而 SetNameOfCopy 方法接收的是结构体的值，这意味着它只能修改副本的内容，不会影响原始结构体。

主函数#

在 main 函数中，我们创建了一个 Cat 实例，并调用了不同的方法来展示其行为。

1
func main() {
2
  cat := New("little pig", "American Shorthair", "cat")
3
  cat.SetName("monster") // (&cat).SetName("monster")
4
  fmt.Printf("The cat: %s\\n", cat)
5

6
  cat.SetNameOfCopy("little pig")
7
  fmt.Printf("The cat: %s\\n", cat)

接口实现#

我们定义了一个 Pet 接口，并检查 Cat 结构体和 *Cat 指针是否实现了该接口。

1
type Pet interface {
2
    SetName(name string)
3
    Name() string
4
    Category() string
5
    ScientificName() string
6
  }
7

8
  _, ok := interface{}(cat).(Pet)
9
  fmt.Printf("Cat implements interface Pet: %v\\n", ok)
10
  _, ok = interface{}(&cat).(Pet)
11
  fmt.Printf("*Cat implements interface Pet: %v\\n", ok)

运行结果#

运行上述代码，输出结果如下：

1
The cat: American Shorthair (category: cat, name: "monster")
2
The cat: American Shorthair (category: cat, name: "monster")
3
Cat implements interface Pet: false
4
*Cat implements interface Pet: true

举一反三#

通过这个示例，我们可以举一反三地应用这些概念。例如，我们可以定义一个 Dog 结构体，并实现类似的方法和接口：

1
type Dog struct {
2
  name           string
3
  scientificName string
4
  category       string
5
}
6

7
func NewDog(name, scientificName, category string) Dog {
8
  return Dog{
9
    name:           name,
10
    scientificName: scientificName,
11
    category:       category,
12
  }
13
}
14

15
func (dog *Dog) SetName(name string) {
16
  dog.name = name
17
}
18

19
func (dog Dog) Name() string {
20
  return dog.name
21
}
22

23
func (dog Dog) ScientificName() string {
24
  return dog.scientificName
25
}
26

27
func (dog Dog) Category() string {
28
  return dog.category
29
}
30

31
func (dog Dog) String() string {
32
  return fmt.Sprintf("%s (category: %s, name: %q)",
33
    dog.scientificName, dog.category, dog.name)
34
}

然后，我们可以在 main 函数中创建 Dog 实例，并检查其行为：

1
func main() {
2
  dog := NewDog("buddy", "Canis lupus familiaris", "dog")
3
  dog.SetName("max")
4
  fmt.Printf("The dog: %s\\n", dog)
5

6
  type Pet interface {
7
    SetName(name string)
8
    Name() string
9
    Category() string
10
    ScientificName() string
11
  }
12

13
  _, ok := interface{}(dog).(Pet)
14
  fmt.Printf("Dog implements interface Pet: %v\\n", ok)
15
  _, ok = interface{}(&dog).(Pet)
16
  fmt.Printf("*Dog implements interface Pet: %v\\n", ok)
17
}

总结#

通过这个教程，我们深入探讨了Go语言中的结构体、方法和接口，并展示了如何举一反三地应用这些概念。理解这些基础知识将帮助你在Go语言中构建更复杂和灵活的程序。