一、结构体
结构体是一系列属性的集合（类似于 Python 中的类）
1、结构体的定义与使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// 定义type Person struct { Name string Age int Sex string}func main() { // 使用 var per Person per.Name="XiaoYang" fmt.Println(per)} |
2、定义并赋初值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
type Person struct { Name string Age int Sex string}func main() { var per1 Person = Person{Name: "XiaoYang"} // 按关键字传参，可以少传 var per2 Person = Person{"Bob", 20, "男"} // 按位置传参，全传 fmt.Println(per1) // 输出：{XiaoYang 0 } fmt.Println(per2) // 输出：{Bob 20 男}} |
3、匿名结构体（只使用一次，没有名字）
|
1
2
3
4
5
6
7
8
|
// 定义个匿名结构体并实例化之后赋值给了 hobby 变量hobby := struct { HobbyId int HobbyName string}{HobbyId: 1, HobbyName: "篮球"}fmt.Println(hobby) // 输出：{1 篮球}fmt.Println(hobby.HobbyName) // 输出：篮球 |
4、结构体的零值
定义好的结构体没有被初始化时，该结构体的字段将默认赋值为零值
也就是我属性的零值，所以他是值类型，参数传递，copy 传递，在函数中修改不会影响原来的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
type Person struct { Name string Age int Sex string}func main() { var per Person=Person{"Bob", 20, "男"} fmt.Println(per) // 输出：{Bob 20 男} test(per) // 输出：{Bob 20 男} fmt.Println(per) // 输出：{Bob 20 男}}func test(per Person) { per.Age=20 fmt.Println(per)} |
5、结构体的指针
|
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
|
// & 放在变量前，表示取该变量的地址// * 放在类型前，表示指向该类型的指针（变量定义，指定类型时才会用到） *[3]int 和 [3]*int// * 放在变量前，表示解引用（取出指针指向的具体的值）type Person struct { Name string Age int Sex string}func main() { var per1 *Person fmt.Println(per1) // 输出：<nil> 表示指针类型 // 定义并初始化 var per2 *Person = &Person{} fmt.Println(per2) // 输出：&{ 0 } // 把per2的名字改成XiaoYang (*per2).Name = "XiaoYang" // 也支持直接使用 per2.Name = "Bob" fmt.Println(per2) // 输出：&{Bob 0 }} |
6、匿名字段（字段没有名字，只有类型）
可用于【变量提升 / 提升字段】类似于面向对象的继承
|
1
2
3
4
5
6
7
8
9
10
11
12
|
// 定义一个结构体，匿名字段类型就是字段名字，所有类型不能重复type Person struct { string int Sex string}func main() { per := Person{"XiaoYang", 20, "男"} // 字段匿名，类型就是字段名 fmt.Println(per) // 输出：{XiaoYang 20 男} fmt.Println(per.string) // 输出：XiaoYang} |
7、嵌套结构体（结构体中套结构体）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
type Person struct { Name string Age int Sex string Hobby Hobby // Person中嵌套Hobby结构体字段}type Hobby struct { HobbyId int HobbyName string}func main() { per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}} fmt.Println(per) // 输出：{XiaoYang 20 男 {1 篮球}} fmt.Println(per.Name) // 输出：XiaoYang fmt.Println(per.Hobby.HobbyName) // 输出：篮球} |
8、字段提升
结构体中有匿名的结构体类型字段，则该匿名结构体里的字段就称为提升字段，可以从外部直接访问
|
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
36
37
38
39
40
41
42
43
44
45
46
|
type Person struct { Name string Age int Sex string Hobby // Person中嵌套Hobby匿名结构体字段}type Hobby struct { HobbyId int HobbyName string}func main() { per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}} // 打印爱好的名字（Hobby是一个匿名字段，会字段提升） fmt.Println(per.HobbyName) // 输出：篮球 // per.hobby 类似于面向对象中的super() fmt.Println(per.Hobby.HobbyName) // 输出：篮球}// ------------------------------------------------------------------------------------// 当子类和父类中的字段名一样时，就像面向对象的继承，子类继承父类（结构体嵌套，匿名字段），子类可以直接调用父类中的属性或方法type Person struct { Name string Age int Sex string Hobby // Person中嵌套Hobby匿名字段}type Hobby struct { HobbyId int Name string}func main() { per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}} fmt.Println(per.Name) // 输出：XiaoYang ——>优先使用自己的 fmt.Println(per.Hobby.Name) // 输出：篮球 ——>指定打印Hobby的名字} |
9、结构体相等性
结构体是值类型。
如果它的每一个字段都是可比较的，则该结构体也是可以比较的。
如果两个结构体变量的对应字段相等，则两个变量也是相等的。
如果结构体包含不可比较的字段，则结构体变量也不可比较。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
type Person struct { Name string Age int Sex string // 包含不可比较的字段 Test []int ——>这是引用类型不可比较}func main() { // 值类型可以直接==比较，引用类型只能跟nil用==比较 per1 := Person{Name: "XiaoYang"} per2 := Person{Name: "XiaoYang"} per3 := Person{Name: "XiaoYang", Age: 20} fmt.Println(per1 == per2) // 输出：ture ——>包含不可比较类型都会直接报错 fmt.Println(per1 == per3) // 输出：false} |
二、方法
方法就是一个特殊函数，在函数的基础上加了一些东西
在func这个关键字和方法名中间加入一个特殊的接收器类型，接收器可以是结构体类型，也可以是非结构体类型
1、方法的定义和使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
type Person struct { Name string Age int Sex string}// 定义一个方法：给Person结构体绑定一个方法，oneself（名字随便取）类似于Python类中的selffunc (oneself Person) printName() { // 在方法内使用oneself fmt.Println(oneself.Name)}func main() { // 使用，对象调用方法 per := Person{} per.Name = "XiaoYang" // 绑定给对象的方法 per.printName() // 输出：XiaoYang} |
2、有了函数为啥还需要方法？
方法功能都能实现，但是呢？它就能指定给某个对象了 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
type Person struct { Name string Age int Sex string}// 方法func (oneself Person) printName() { fmt.Println(oneself.Name)}// 函数func printName(oneself Person) { fmt.Println(oneself.Name)}func main() { per := Person{Name: "XiaoYang"} per.printName() // 方法的特殊之处，可以自动传递值 printName(per) // 函数需要手动传递值} |
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
31
|
type Person struct { Name string Age int Sex string}// 值接收器修改名字func (oneself Person) changeName(name string) { oneself.Name = name}// 指针接收器修改年龄func (oneself *Person) changeAge(age int) { oneself.Age = age}func main() { per := Person{Name: "XiaoYang", Age: 20} fmt.Println(per) // 输出：{XiaoYang 20 } per.changeName("Bob")// 由于这个是值接收器，它是copy一份传递过去所以修改的是copy的不会改掉原来的 per.changeAge(18) // 指针接收器，它传递的是指针 fmt.Println(per) // 输出：{XiaoYang 18 }}/*什么时候用指针接收器，什么时候使用值接收器： -想改原来的，就用指针 -不想改原来的，就用值*/ |
5、匿名字段的方法（方法提升）
|
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
36
|
type Person struct { Name string Age int Sex string Hobby // 匿名字段}type Hobby struct { Id int Name string}// 打印Person的名字func (oneself Person) printName() { fmt.Println(oneself.Name)}// 打印Hobby的名字func (oneself Hobby) printHobbyName() { fmt.Println(oneself.Name)}// 打印Hobby的名字func (oneself Hobby) printName() { fmt.Println(oneself.Name)}func main() { per := Person{Name: "XiaoYang", Hobby: Hobby{1, "篮球"}} per.printName() // 输出：XiaoYang per.printHobbyName() // 输出：篮球 // 如果方法重名了，优先使用结构体自己的 per.printName() // 输出：XiaoYang per.Hobby.printName() // 输出：篮球} |
6、在方法中使用值接收器 与 在函数中使用值参数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
type Person struct { Name string Age int Sex string}// 在方法中使用值接收器func (oneself Person) printName() { fmt.Println(oneself.Name)}// 在函数中使用值参数func printName(oneself Person) { fmt.Println(oneself.Name)}func main() { per1 := &Person{Name: "XiaoYang"} // per1是个指针 per2 := Person{Name: "Bob"} printName(*per1) // 输出：XiaoYang per1.printName() // 输出：XiaoYang ———> 值收器:可以用值来调，也可以用指针来调 per2.printName() // 输出：Bob} |
7、在方法中使用指针接收器 与 在函数中使用指针参数
|
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
36
37
38
|
type Person struct { Name string Age int Sex string}// 在方法中使用指针接收器func (oneself *Person) printName() { fmt.Println(oneself.Name)}func (oneself *Person)changeName(name string) { oneself.Name=name}// 在函数中使用指针参数func printName(oneself *Person) { fmt.Println(oneself.Name)}func main() { per1 := Person{Name: "XiaoYang"} per2 := &Person{Name: "Bob"} // per1是个指针 per1.printName() // 值可以调用 printName(&per1) per2.printName() // 指针可以调用 printName(per2) per1.changeName("Alen") // 可以修改 fmt.Println(per1) per2.changeName("YS") // 可以修改 fmt.Println(per2)} |
总结：
- -不管是值类型接收器还是指针类型接收器，都可以用值来调用，或者指针来调用。
- -不管是值还是指针来调用，只要是值类型接收器，改的就是新的，只要是指针类型接收器，改的是原来的。
8、非结构体上绑定方法
不允许在基础数据类型上绑定方法（如：int、string ... )
但是自己定义的类型可以绑定方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
type Myint intfunc (i *Myint) add() { (*i)++}func main() { var a Myint = 10 fmt.Println(a) // 输出：10 a.add() a.add() a.add() fmt.Println(a) // 输出：13} |
到此这篇关于Go语言之结构体与方法的文章就介绍到这了,更多相关Go语言之结构体内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.cnblogs.com/XiaoYang-sir/p/15376845.html
