不做大哥好多年
xiaonaiqiang
2021-05-19
目录

11.结构体

# 01.结构体基础

# 1.1 什么是结构体

  • Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。
  • Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

# 1.2 自定义类型

  • 在 Go 语言中有一些基本的数据类型，如 string、整型、浮点型、布尔等数据类型

  • Go 语言中可以使用 type 关键字来定义自定义类型。

  • 将 myInt 定义为 int 类型，通过 type 关键字的定义，myInt 就是一种新的类型，它具有 int 的特性

type myInt int
1

# 1.3 类型别名

  • Golang1.9 版本以后添加的新功能。

  • 类型别名规定：TypeAlias 只是 Type 的别名，本质上 TypeAlias 与 Type 是同一个类型

  • 就像 一个孩子小时候有大名、小名、英文名，但这些名字都指的是他本人。

type TypeAlias = Type
1

# 1.4 自定义类型和类型别名的区别

  • 类型别名与自定义类型表面上看只有一个等号的差异
  • 结果显示 a 的类型是 main.newInt，表 示 main 包下定义的 newInt 类型。
  • b 的类型是 int 类型。
package main
import "fmt"
type newInt int      //类型定义
type myInt = int      //类型别名
func main() {
	var a newInt
	var b myInt
	fmt.Printf("type of a:%T\n", a)   //type of a:main.newInt
	fmt.Printf("type of b:%T\n", b)   //type of b:int
}
1
2
3
4
5
6
7
8
9
10

# 02.结构体定义

# 2.1 基本实例化（法1）

  • 只有当结构体实例化时，才会真正地分配内存，也就是必须实例化后才能使用结构体的字段。

  • 结构体本身也是一种类型，我们可以像声明内置类型一样使用 var 关键字声明结构体类型

package main
import "fmt"
type person struct {
	name string
	city string
	age int
}
func main() {
	var p1 person
	p1.name = "张三"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)   // p1={张三 北京 18}
	fmt.Printf("p1=%#v\n", p1)   // p1=main.person{name:"张三", city:"北京", age:18}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 2.2 new实例化（法2）

  • 我们还可以通过使用 new 关键字对结构体进行实例化，得到的是结构体的地址
  • 从打印的结果中我们可以看出 p2 是一个结构体指针。
  • 注意：在 Golang 中支持对结构体指针直接使用.来访问结构体的成员。
  • p2.name = "张三" 其实在底层是 (*p2).name = "张三"
package main
import "fmt"
type person struct {
	name string
	city string
	age int
}
func main() {
	var p2 = new(person)
	p2.name = "张三"
	p2.age = 20
	p2.city = "北京"
	fmt.Printf("%T\n", p2)    //*main.person
	fmt.Printf("p2=%#v\n", p2)  //p2=&main.person{name:"张三", city:"北京", age:20}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 2.3 &取地址实例化（法3）

  • 使用&对结构体进行取地址操作相当于对该结构体类型进行了一次 new 实例化操作
package main
import "fmt"
type person struct {
	name string
	city string
	age int
}
func main() {
	p3 := &person{}
	fmt.Printf("%T\n", p3)    //*main.person
	fmt.Printf("p3=%#v\n", p3)  //p3=&main.person{name:"", city:"", age:0}
	p3.name = "zhangsan"
	p3.age = 30
	p3.city = "深圳"
	(*p3).age = 40   //这样也是可以的
	fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"zhangsan", city:"深圳", age:30}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 2.4 键值对初始化（法4）

  • 注意：最后一个属性的,要加上
package main
import "fmt"
type person struct {
	name string
	city string
	age int
}
func main() {
	p4 := person{
		name: "zhangsan",
		city: "北京",
		age: 18,
	}
	// p4=main.person{name:"zhangsan", city:"北京", age:18}
	fmt.Printf("p4=%#v\n", p4)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 2.5 值列表初始化（法5）

  • 初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值
  • 必须初始化结构体的所有字段。
  • 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
  • 该方式不能和键值初始化方式混用
package main
import "fmt"
type person struct {
	name string
	city string
	age int
}
func main() {
	// 初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值
	p7 := &person{
		"zhangsan",
		"北京",
		28,
	}
	// p7=&main.person{name:"zhangsan", city:"北京", age:28}
	fmt.Printf("p7=%#v\n", p7)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 2.6 结构体的匿名字段

  • 结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

  • 匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

package main
import "fmt"

type Person struct {  //Person 结构体 Person 类型
	string
	int
}
func main() {
	p1 := Person{
		"小王子",
		18,
	}
	fmt.Printf("%#v\n", p1)   //main.Person{string:"北京", int:18}
	fmt.Println(p1.string, p1.int)    //北京 18
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 03.嵌套结构体

# 3.1 普通嵌套结构体

  • 一个结构体中可以嵌套包含另一个结构体或结构体指针。
package main
import "fmt"
type Address struct {   //Address 地址结构体
	Province string
	City string
}
type User struct {   //User 用户结构体
	Name string
	Gender string
	Address Address
}
func main() {
	user1 := User{
		Name: "张三",
		Gender: "男",
		Address: Address{
			Province: "广东",
			City: "深圳",
		},
	}
	fmt.Printf("user1=%#v\n", user1) 
	//user1=main.User{Name:" 张 三 ", Gender:" 男 ", Address:main.Address{Province:"广东", City:"深圳"}}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 3.2 嵌套匿名结构体

  • 注意：当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。
package main
import "fmt"
type Address struct {  //Address 地址结构体
	Province string
	City string
}
type User struct {   //User 用户结构体
	Name string
	Gender string
	Address
}
func main() {
	var user2 User
	user2.Name = "张三"
	user2.Gender = "男"
	user2.Address.Province = "广东"   //通过匿名结构体.字段名访问
	user2.City = "深圳"   //直接访问匿名结构体的字段名
	fmt.Printf("user2=%#v\n", user2)
	//user2=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 04.结构体方法和接收者

# 4.1 结构体说明

  • 在 go 语言中，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。
  • 所谓方法就是定义了接收者的函数。
    • Go语言中的方法（Method）是一种作用于特定类型变量的函数。
    • 这种特定类型变量叫做接收者（Receiver）。
    • 接收者的概念就类似于其他语言中的this或者 self。
  • 方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
	函数体
}
1
2
3
  • 给结构体 Person 定义一个方法打印 Person 的信息

# 4.2 结构体方法和接收者

package main
import "fmt"
type Person struct {
	name string
	age int8
}
func (p Person) printInfo() {
	fmt.Printf("姓名:%v 年龄:%v", p.name, p.age)  // 姓名:小王子 年龄:25
}
func main() {
	p1 := Person{
		name: "小王子",
		age:  25,
	}
	p1.printInfo()  // 姓名:小王子 年龄:25
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 4.3 值类型和指针类型接收者

  • 实例1：给结构体 Person 定义一个方法打印 Person 的信息

  • 1、值类型的接收者

    • 当方法作用于值类型接收者时，Go 语言会在代码运行时将接收者的值复制一份。
    • 在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。

  • 2、指针类型的接收者

    • 指针类型的接收者由一个结构体的指针组成
    • 由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
    • 这种方式就十分接近于其他语言中面向对象中的 this 或者 self。
package main
import "fmt"
type Person struct {
	name string
	age int
}
//值类型接受者
func (p Person) printInfo() {
	fmt.Printf("姓名:%v 年龄:%v\n", p.name, p.age)  // 姓名:小王子 年龄:25
}
//指针类型接收者
func (p *Person) setInfo(name string, age int) {
	p.name = name
	p.age = age
}
func main() {
	p1 := Person{
		name: "小王子",
		age: 25,
	}
	p1.printInfo()     // 姓名:小王子 年龄:25
	p1.setInfo("张三", 20)
	p1.printInfo()     // 姓名:张三 年龄:20
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 05.结构体继承

  • Go 语言中使用结构体也可以实现其他编程语言中的继承

# 5.1 普通传值

package main
import "fmt"
type Animal struct {   //Animal 动物
	name string
}
func (a *Animal) run() {
	fmt.Printf("%s 会运动！\n", a.name)
}
type Dog struct {   //Dog狗
	Age int8
	Animal    // 通过嵌套匿名结构体实现继承
}
func (d Dog) wang() {
	fmt.Printf("%s 会汪汪汪~\n", d.name)
}
func main() {
	d1 := Dog{
		Age: 4,
		Animal: Animal{    //注意嵌套的是结构体指针
			name: "阿奇",
		},
	}
	d1.wang()    //乐乐会汪汪汪~
	d1.run()    //乐乐会动！
}
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

# 5.2 指针传值

package main
import "fmt"
type Animal struct {   //Animal 动物
	name string
}
func (a *Animal) run() {
	fmt.Printf("%s 会运动！\n", a.name)
}
type Dog struct {   //Dog狗
	Age int8
	*Animal  //通过嵌套匿名结构体实现继承
}
func (d *Dog) wang() {
	fmt.Printf("%s 会汪汪汪~\n", d.name)
}
func main() {
	d1 := &Dog{
		Age: 4,
		Animal: &Animal{    //注意嵌套的是结构体指针
			name: "阿奇",
		},
	}
	d1.wang()    //乐乐会汪汪汪~
	d1.run()    //乐乐会动！
}
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

# 06.给任意类型添加方法

  • 在 Go 语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。

  • 举个例子，我们基于内置的 int 类型使用 type 关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

  • 注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

package main
import "fmt"

type myInt int
func (m myInt) SayHello() {
	fmt.Println("Hello, 我是一个 int。")
}
func main() {
	var m1 myInt
	m1.SayHello()    //Hello, 我是一个 int。
	m1 = 100
	fmt.Printf("%#v %T\n", m1, m1)   //100 main.MyInt
}
1
2
3
4
5
6
7
8
9
10
11
12
13
上次更新: 2024/3/13 15:35:10
10.指针
12.interface接口

← 12.interface接口→

最近更新
01
16.CAP
09-27
02
13.HTTP协议
09-25
03
12.TCP协议
09-25
更多文章>
Theme by Vdoing | Copyright © 2019-2024 逍遥子 技术博客 京ICP备2021005373号