Go没有沿袭传统面向对象编程中的诸多概念，也没有提供类(class)，但是它提供了结构体(struct)，方法(method)可以在结构体上添加。与类相似，结构体提供了捆绑数据和方法的行为。

1. 介绍

1.1 概念

单一的数据类型已经满足不了现实开发需求，于是 Go 语言提供了结构体来定义复杂的数据类型。结构体是由一系列相同类型或不同类型的数据构成的数据集合。结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存。因此必须在定义结构体并实例化后才能使用结构体的字段。

1.2 语法

1
2
3
4
5

type 类型名称 struct {
   field type
   field type 
   field1,field2,field3 type // 同类型变量可以写在一行
}

1.3 注意事项

  • 类型名是标识结构体的名称，在同一个包内不能重复。
  • 结构体的属性，也叫字段(field)，必须唯一。
  • 同类型的成员属性可以写在一行。
  • 结构体是值类型。
  • 只有当结构体实例化时,才能使用结构体的字段。

2. 实例化

2.1 使用var

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main
import "fmt"
// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    // 使用var 实例化结构体
    var s student
    fmt.Printf("变量s--> 类型: %T 值: %v \n",s,s)
    // 给属性赋值
    s.name = "张三"
    s.age = 20
    s.like = []string{"打游戏","看动漫"}
    fmt.Printf("给属性赋值: 变量s--> 类型: %T 值: %v \n",s,s)
}
/*输出
变量s--> 类型: main.student 值: { 0 []} 
给属性赋值: 变量s--> 类型: main.student 值: {张三 20 [打游戏 看动漫]} 
*/

2.2 使用简短声明 (:=)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main
import "fmt"
// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    // 方式一: 先实例化结构体，后赋值
    s := student{}
    // 给属性赋值
    s.name = "张三"
    s.age = 20
    s.like = []string{"打游戏","看动漫"}
    fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
    
    // 方式二: 声明时初始化
    s1 := student{
        name: "李四",
        age:  23,
        like: []string{"旅游","运动"},
    }
    fmt.Printf(" 变量s1--> 类型: %T 值: %v \n",s1,s1)
    
    // 方式三: 声明时初始化，省略属性
    s2 := student{"王麻子",30,[]string{"睡觉","吃饭"}}
    fmt.Printf(" 变量s2--> 类型: %T 值: %v \n",s2,s2)
}
/**输出
 变量s--> 类型: main.student 值: {张三 20 [打游戏 看动漫]} 
 变量s1--> 类型: main.student 值: {李四 23 [旅游 运动]} 
 变量s2--> 类型: main.student 值: {王麻子 30 [睡觉 吃饭]} 
*/

2.3 使用new

使用内置函数new()对结构体进行实例化，结构体实例化后形成指针类型的结构体，new()内置函数会分配内存。第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main
import "fmt"

// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    // 使用new实例化
    s := new(student)
    fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
    // 给属性赋值
    (*s).name = "包青天"
    (*s).age = 55
    (*s).like = []string{"判案"}
    fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
    // 语法糖写法(省略*)
    s.name = "包大人"
    s.age = 99
    s.like = []string{"判案","元芳你怎么看"}
    fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
}
/**输出
 变量s--> 类型: *main.student 值: &{ 0 []} 
 变量s--> 类型: *main.student 值: &{包青天 55 [判案]} 
 变量s--> 类型: *main.student 值: &{包大人 99 [判案 元芳你怎么看]} 
*/

3. 结构体在函数中使用

结构体作为函数参数，若复制一份传递到函数中，在函数中对参数进行修改，不会影响到实际参数，证明结构体是值类型。

3.1 传结构体值作为参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main
import "fmt"

// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    s := student{name:"张三",age:17}
    grownUp(s)
    fmt.Printf("调用函数后,变量s--> 值: %v \n",s)
}
// 传结构体值作为参数
func grownUp( s student)  {
    s.age = 80
    s.name = "长大的 "+s.name
}
/**输出
 变量s--> 值: {张三 17 []} 
 调用函数后,变量s--> 值: {张三 17 []} 
*/

3.2 传结构体指针作为参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main
import "fmt"

// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    s := student{name:"张三",age:17}
    fmt.Printf(" 变量s--> 值: %v \n",s)
    // 取址
    grownUp(&s)
    fmt.Printf("调用函数后,变量s--> 值: %v \n",s)
}
// 传结构体指针作为参数
func grownUp( s *student)  {
    s.age = 80
    s.name = "长大的 "+s.name
}
/** 输出:
 变量s--> 值: {张三 17 []} 
 调用函数后,变量s--> 值: {长大的 张三 80 []} 
*/

3.3 返回对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main
import "fmt"

// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    s := getStudent("杨过",40,[]string{"骑大雕"})
    fmt.Printf("函数返回值 s--> 值: %v  类型: %T \n",s,s)
}
// 作为值类型传递
func getStudent( name string, age int,likes []string) student  {
    return student{name,age,likes}
}
// 函数返回值 s--> 值: {杨过 40 [骑大雕]}  类型: main.student

3.4 返回指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main
import "fmt"

// 定义结构体
type student struct {
    name string
    age int
    like []string
}
func main() {
    s := getStudent("杨过",40,[]string{"骑大雕"})
    fmt.Printf("函数返回值 s--> 值: %v  类型: %T \n",s,s)
}

// 返回指针
func getStudent( name string, age int,likes []string) *student  {
    return &student{name,age,likes}
}
// 输出: 函数返回值 s--> 值: &{杨过 40 [骑大雕]}  类型: *main.student

4.匿名结构体

4.1 语法

1
2
3

变量名 := struct {
  // 定义成员属性
} { /*初始化成员属性*/ }

4.2 使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main
import "fmt"
func main() {
    // 声明初始化匿名结构体
    s := struct {
        name, home, phone string
        age               int
    }{
        name:  "张二十",
        phone: "17600111111",
        age:   18,
    }
    // 打印
    fmt.Printf("变量 s--> 值: %v  类型: %T \n", s, s)
}
// 输出: 变量 s--> 值: {张二十  17600111111 18}  类型: struct { name string; home string; phone string; age int }

5.匿名字段

5.1 定义

匿名字段就是在结构体中的字段没有名字，只包含一个没有字段名的类型。这些字段被称为匿名字段。在同一个结构体中,同一个类型只能有一个匿名字段。

5.2 使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main
import "fmt"
type people struct {
    name, home string
    int        // 匿名字段
    float32    // 匿名字段
}
func main() {
    // 声明初始化匿名结构体
    s := people{name: "张三", home: "北京", int: 18, float32: 1.73}
    fmt.Printf("变量 s--> 值: %v \n", s)
    // 声明初始化匿名结构体(省略属性名)
    s2 := people{"李四", "南京", 22, 1.80}
    fmt.Printf("变量 s2--> 值: %v \n", s2)
}
/** 输出
  变量 s--> 值: {张三 北京 18 1.73} 
  变量 s2--> 值: {李四 南京 22 1.8} 
*/

6. 结构体嵌套

6.1 定义

将一个结构体作为另一个结构体的属性（字段），这种结构就是结构体嵌套。

结构体嵌套可以模拟面向对象编程中的以下两种关系。

  • 聚合关系: 一个类作为另一个类的属性。
  • 继承关系: 一个类作为另一个类的子类。子类和父类的关系。

6.2 聚合场景

模拟聚合关系时一定要采用有名字的结构体作为字段。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main
import "fmt"
// 定义学生结构体
type student struct {
    name       string
    height      float32
    schoolInfo  school
}
// 定义学习结构体
type school struct {
    schoolName, schoolAddress string
}
func main() {
    // 简短声明嵌套结构体
    s := student{"小张",1.72,school{"北京大学","北京"}}
    fmt.Printf("变量 s--> 值: %v 类型: %T \n", s,s)
    // 使用var
    var ss student
    ss.name = "小龙"
    ss.height = 1.67
    ss.schoolInfo = school{"南京大学","南京"}
    fmt.Printf("变量 ss--> 值: %v 类型: %T \n", ss,ss)
    // 使用new
    s2 := new(student)
    s2.name = "小虎"
    s2.height = 1.77
    s2.schoolInfo.schoolName = "武汉大学"
    s2.schoolInfo.schoolAddress = "武汉"
    fmt.Printf("变量 s2--> 值: %v 类型: %T \n", s2,s2)
}
/** 输出:
  变量 s--> 值: {小张 1.72 {北京大学 北京}} 类型: main.student 
  变量 ss--> 值: {小龙 1.67 {南京大学 南京}} 类型: main.student 
  变量 ss--> 值: &{小虎 1.77 {武汉大学 武汉}} 类型: *main.student 
*/

6.3 模拟继承

在结构体中，属于匿名结构体的字段称为提升字段，它们可以被访问，匿名结构体就像是该结构体的父类。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main
import "fmt"

// 定义父类结构体
type people struct {
    name  string
    age   int
}
type student struct {
    people // 集成父类结构体
    class string
}

func main() {
    // 方式1.使用new声明结构体
    var s = new(student)
    // 集成父类成员
    s.name = "张三"
    s.age = 12
    // 自己成员
    s.class = "三年级"
    fmt.Printf("变量s -> %v \n",s)
    // 方式2.使用简短声明
    s2 := student{people{"李四",13},"四年级"}
    fmt. ("变量s2 -> %v \n",s2)
}
/** 输出
变量s -> &{{张三 12} 三年级} 
变量s2 -> {{李四 13} 四年级} 
*/

6.4 成员冲突

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main
import "fmt"
type A struct {
    name string
    age  int
}
type B struct {
    name   string
    height float32
}
// 在C结构体中嵌套A和B
type C struct {
    A
    B
}
func main() {
    // 定义结构体C
    c := C{}
    // 不冲突的成员赋值
    c.age = 12
    c.height = 1.88
    // 冲突的成员赋值
    c.A.name = "这是A的成员"
    c.B.name = "这是B的成员"
    fmt.Printf("变量c -> %v \n", c)
}
// 输出: 变量c -> {{这是A的成员 12} {这是B的成员 1.88}}