Go-18 Golang结构体struct详解

package main

import "fmt"

// Golang中的结构体详解

type newInt int  // 自定义类型
type myInt = int // 类型别名
type zsInt int

type person struct {
	name string
	city string
	age  int8
}

type PerSon struct {
	name string
	age  int
}

// 匿名字段结构体
type PersonMan struct {
	string
	int
}

// 定义Address地址结构体
type Address struct {
	Province string
	City     string
}

// 定义User用户结构体
type User struct {
	Name    string
	Gender  string
	Address Address // 在这里就是结构体中嵌套了另一个结构体
}

// UserT 用户结构体中嵌套匿名结构体
type UserT struct {
	Name    string
	Gender  string
	Address // 匿名结构体
}

// Animal 动物
type Animal struct {
	name string
}

// Dog 狗
type Dog struct {
	Age     int8
	*Animal // 通过嵌套匿名结构体实现继承
}

func (a *Animal) run() {
	fmt.Printf("%s 会运动！ \n", a.name)
}

func (d *Dog) wang() {
	fmt.Printf("%s 会汪汪汪~  \n", d.name)
}

// 值类型接收者
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 (m zsInt) SayHello() {
	fmt.Println("Hello, 我是一个int...")
}

func main() {
	/*
		1.关于Golang结构体
			Golang中没有"类"的概念，Golang中的结构体和其他语言中的类有点相似。和其他面向对象语言中的类相比，
			Golang中的结构体具有更高的扩展性和灵活性。
		Golang结构体因何而出：
			Golang中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事务的全部或部分属性时，这时候再用单一的基本数据类型就无法满足
			要求了，Golang中提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名struct。也就是我们可以通过struct
			来定义我们自己的类型了。

		2.Golang type 关键字自定义类型和类型别名
			Golang中通过type关键字定义一个结构体。
			2.1 type自定义类型
				在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。
				type myint int	这个表示将myint定义为int类型，通过type关键字的定义，myint就是一种新的类型，它具有int的特性。

			2.2 定义类型别名
				Golang1.9版本以后添加的新功能。类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像
				一个小孩小时候有大名、小明、英文名，但这些名字都指的是他本人。
				type TypeAlias = Type	,我们之前见过的rune和byte就是类型别名，他们的底层定义如下：
				type byte = uint8
				type rune = int32

			2.3 自定义类型和类型别名的区别
				类型别名与自定义类型表面上看只有一个等号的差异，我们通过下面的这段代码来理解他们之间的区别。
				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
				}
				结果显示a的类型是main.newInt,表示main包下定义的newInt类型。b的类型是int类型。

		3.结构体定义初始化的几种方法
			3.1 结构体的定义
				使用type和struct关键字来定义结构体，具体代码格式如下：
				type 类型名 struct {
					字段名 字段类型
					字段名 字段类型
					字段名 字段类型
					..... ......
				}
				其中：
					1.类型名：表示自定义结构体的名称，在同一个包内不能重复。
					2.字段名：表示结构体字段名。结构体中的字段名必须唯一。
					3.字段类型：表示结构体字段的具体类型。
				举例，我们定义一个person人类的结构体，代码如下：
				type person struct {
					name string
					city string
					age int8
				}
				同样类型的字段也可以写在一行：
				type person struct {
					name, city string
					age int8
				}
				注意：结构体首字母可以大写，也可以小写，大写表示这个结构体是公有的，在其他的包里面可以使用。小写表示这个结构体是私有的，只有这个包里面才能使用。
			3.2 结构体实例化（第一种方法）
				只有当结构体实例化时，才会真正的分配内存。也就是必须实例化后才能使用结构体的字段。结构体本身也是一种类型，我们可以
				像声明内置类型一样使用var关键字声明结构体类型。	var 结构体实例 结构体类型，例如借用上面的结构体进行声明：var p1 person
				package main
				import "fmt"
				type person struct {
					name string
					city string
					age int8
				}
				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}
				}

			3.3 结构体实例化（第二种方法）
				我们可以使用new关键字对结构体进行实例化，得到的是结构体的地址。格式如下：
				package main
				import "fmt"
				type person struct {
					name string
					city string
					age int
				}
				func main() {
					var p2 = new(person)
					p2.name = "张三"
					p2.city = "北京"
					p2.age = 20
					fmt.Printf("%T \n", p2)	// *main.person
					fmt.Printf("p2=%#v \n", p2)	//p2=&main.person{name:"张三",city:"北京",age:20}
				}
				从打印的结果中我们可以看出p2是一个结构体指针。注意：在Golang中支持对结构体指针直接使用，来访问结构体的成员。
				p2.name="张三" 其实在底层是(*p2).name="张三"

			3.4 结构体实例化（第三种方法）
				使用&对结构体进行取地址操作。
				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 = "张三"
					p3.city = "北京"
					p3.age = 20
					// (*p3).age = 50	// 这样也是可以的
					fmt.Printf("p3=%#v \n", p3)	// p3=&main.person{name:"张三",city:"北京",age:20}
				}

			3.5 结构体实例化（第四种方法）键值对初始化
				package main
				import "fmt"
				type person struct {
					name string
					city string
					age int
				}
				func main() {
					p4 := person{
						name:"张三",
						city:"北京",
						age:18,		// 要注意，最后一个属性的逗号要加上不能丢。
					}
					fmt.Printf("p4=%#v \n", p4)	// p4=&main.person{name:"张三",city:"北京",age:18}
				}
			3.6 结构体实例化（第五种方法）结构体指针进行键值对初始化
				package main
				import "fmt"
				type person struct {
					name string
					city string
					age int
				}
				func main() {
					p5 := &person{
						name: "张三",
						city: "北京",
						age: 28,
					}
					fmt.Printf("p5=%#v \n", p5)	// p5=&main.person{name:"张三",city:"北京",age:28}
				}
				当某些字段没有初始值的时候，这个字段可以不写。此时，没有指定初始值的字段采用类型的零值。
				package main
				import "fmt"
				type person struct {
					name string
					city string
					age int
				}
				func main() {
					p6 := &person{
						city: "北京",
					}
					fmt.Printf("p6=%#v \n", p6)	// p6=&main.person{name:"",city:"北京",age:0}
				}
			3.7 结构体实例化（第六种方法）使用值的列表初始化
				package main
				import "fmt"
				type person struct {
					name string
					city string
					age int
				}
				func main() {
					p7 := &person{
						"zhangsan",
						"北京",
						28,
					}
					fmt.Printf("p7=%#v \n", p7)	// p7=&main.person{name:"zhangsan",city:"北京",age:28}
				}
				!!! 使用这种格式初始化时，需要注意：
					1. 必须初始化结构体的所有字段。
					2. 初始值的填充顺序必须和字段在结构体中的声明顺序一致。
					3. 该方式不能和键值初始化方式混用。

		4.结构体方法和接收者
			在Go语言中，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。所谓方法就是定义了接收者的函数。
			接收者的概念就类似于Python语言中的self。
			方法的定义格式如下：
			func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
				函数体
			}
			其中：
				1.接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。
					例如，Person类型的接收者变量应该命名为小写字母p,Connector类型的接收者变量应该命名为c等。总之接收者变量就是用小写字母。
				2.接收者类型：接收者类型和参数类似，可以时指针类型和非指针类型。
				3.方法名、参数列表、返回参数：具体格式与函数定义相同。
			实例1: 给结构体Person定义一个方法打印Person的信息
			package main
			import "fmt"
			type PerSon struct {
				name string
				age int8
			}
			// 值类型接收者
			func (p PerSon) printInfo() {
				fmt.Printf("姓名：%v 年龄：%v \n", p.name, p.age)
			}
			func main() {
				p1 := PerSon{
					name: "小王子",
					age: 25,
				}
				p1.printInfo()
			}
			4.1 值类型的接收者-------> 就是传入的参数类型前面没有*符号
				当方法作用域值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，
				但修改操作只是针对副本，无法修改接收者变量本身。
			4.2 指针类型的接收者--------> 就是传入的参数在类型前面会加上*符号
				指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
				这种方式就十分接近于其他语言中面向对象中的this或者self。
				下面写一下值类型和指针类型接收的示例：
				package main
				import "fmt"
				type Person struct {
					name string
					age int
				}
				// 下面定义一个printInfo方法和一个setInfo方法并绑定给结构体Person.
				// 值类型接收者
				func (p Person) printInfo() {
					fmt.Printf("姓名：%v   年龄：%v \n", p.name, p.age)
				}
				// 指针类型接收者
				func (p *Person) setInfo(name string, age int) {
					p.name = name
					p.age = age
				}
				func main() {
					p1 := Person{
						name: "小王子",
						age: 25,
					}
					p1.printInfo()
					p1.setInfo("张三", 20)
					p1.printInfo()
				}
				// 上面的运行结果是：
				值类型接收者和指针类型接收者运行结果：
				姓名：小王子 年龄：25
				姓名：张三 年龄：20

		5.给任意类型添加方法
			在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。举个例子：
			我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
			package main
			import "fmt"
			type zsInt int
			func (m zsInt) SayHello() {
				fmt.Println("Hello, 我是一个int...")
			}
			func main() {
				var m1 zsInt
				m1.SayHello() // Hello, 我是一个int...
				m1 = 100
				fmt.Printf("%#v	%T \n", m1, m1) // 100  main.zsInt
			}
			注意事项：非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

		6.结构体的匿名字段
			结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
			type PersonMan struct {
				string
				int
			}
			func main() {
				p1 := PersonMan{
					"小王子",
					18,
				}
				fmt.Printf("%#v \n", p1)	// main.PersonMan{string:"北京", int:18}	------>>>> 匿名字段默认采用类型名作为字段名
				fmt.Println(p1.string, p1.int)	// 北京  18
			}
			匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
			简而言之就是每种类型只能出现一次，不能重复。

		7.嵌套结构体
			一个结构体中可以嵌套包含另一个结构体或结构体指针。
			package main
			import "fmt"
			// 定义Address地址结构体
			type Address struct {
				Province string
				City string
			}
			// 定义User用户结构体
			type User struct {
				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:"深圳"}}
			}


		8.嵌套匿名结构体
			package main
			import "fmt"
			// Address 地址结构体
			type Address struct{
				Province string
				City string
			}
			// User 用户结构体
			type User struct{
				Name string
				Gender string
				Address 	// 匿名结构体
			}
			func main() {
				var user2 UserT
				user2.Name = "张三"
				user2.Gender = "男"
				user2.Address.Province = "广东" // 通过匿名结构体.字段名访问
				user2.City = "深圳"             // 直接访问匿名结构体的字段名
				fmt.Printf("user2=%#v \n", user2)
				// 结果是：user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
			}
			【注意】：当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。这就是为什么可以用User2.City = "深圳" 不报错的原因。

		9.关于嵌套结构体的字段名冲突
			嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体字段。
			package main
			import "fmt"
			// Address 地址结构体
			type Address struct {
				Province string
				City string
				CreateTime string
			}
			// Email 邮箱结构体
			type Email struct {
				Account string
				CreateTime string
			}
			// User用户结构体
			type User struct {
				Name string
				Gender string
				Address
				Email
			}
			func main() {
				var user3 User
				user3.Name = "张三"
				user3.Gender = "男"
				//user3.CreateTime = "2020"	// 这样是错误的，嵌套结构体内部有相同的字段，需要指名道姓用点的方式
				user3.Address.CreateTime = "2020"	// 指定Address结构体中的CreateTime
				user3.Email.CreateTime = "2021"		// 指定Email结构体中的CreateTime
			}

		10.结构体的继承
			Go 语言中使用结构体也可以实现其他编程语言中的继承。
			package main
			import "fmt"
			// Animal 动物
			type Animal struct {
				name string
			}
			func(a *Animal) run() {
				fmt.Printf("%s 会运动！ \n", a.name)
			}
			// Dog 狗
			type Dog struct {
				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()	// 阿奇会运动！
			}



	*/
	// 自定义类型 和 类型别名的打印结果
	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
	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}

	// 结构体实例化方法2
	var p2 = new(person)
	p2.name = "张三"
	p2.city = "北京"
	p2.age = 20
	fmt.Printf("%T \n", p2)     // *main.person
	fmt.Printf("p2=%#v \n", p2) //p2=&main.person{name:"张三",city:"北京",age:20}

	// 结构体实例化方法3
	p3 := &person{}
	fmt.Printf("%T \n", p3)     // *main.person
	fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"",city:"",age:0}
	p3.name = "张三"
	p3.city = "北京"
	p3.age = 20
	// (*p3).age = 50	// 这样也是可以的
	fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"张三",city:"北京",age:20}

	// 打印结构体的信息
	pp := PerSon{
		name: "小王子",
		age:  25,
	}
	pp.printInfo() // 姓名：小王子 年龄：25

	// 值类型接收者和指针类型接收者
	fmt.Println("值类型接收者和指针类型接收者运行结果：")
	p2p := PerSon{
		name: "小王子",
		age:  25,
	}
	p2p.printInfo()
	p2p.setInfo("张三", 20)
	p2p.printInfo()
	/*	// 上面的运行结果是：
		值类型接收者和指针类型接收者运行结果：
		姓名：小王子 年龄：25
		姓名：张三 年龄：20
	*/

	// 给任意类型添加个方法
	println()
	var m1 zsInt
	m1.SayHello() // Hello, 我是一个int...
	m1 = 100
	fmt.Printf("%#v	%T \n", m1, m1) // 100  main.zsInt

	// 匿名字段结构体
	println()
	pm := PersonMan{
		"小王子",
		18,
	}
	fmt.Printf("%#v \n", pm)       // main.PersonMan{string:"小王子", int:18}
	fmt.Println(pm.string, pm.int) // 小王子 18

	// 嵌套结构体
	println()
	user1 := User{
		Name:   "张三",
		Gender: "男",
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}
	fmt.Printf("user1=%#v \n", user1)
	// 结果是：user1=main.User{Name:"张三",Gender:"男",Address:main.Address{Province:"广东",City:"深圳"}}

	// 嵌套匿名结构体
	println()
	var user2 UserT
	user2.Name = "张三"
	user2.Gender = "男"
	user2.Address.Province = "广东" // 通过匿名结构体.字段名访问
	user2.City = "深圳"             // 直接访问匿名结构体的字段名
	fmt.Printf("user2=%#v \n", user2)
	// 结果是：user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}

	// 关于结构体的继承
	println()
	d1 := &Dog{
		Age: 4,
		Animal: &Animal{ // 注意嵌套的是结构体指针
			name: "阿奇",
		},
	}
	d1.wang() // 阿奇会汪汪汪~
	d1.run()  // 阿奇会运动！
	// 发现这个用法和Python中类的继承用法是一样的，继承父类的方法和属性都可以通过点的方式去调用。

	/*	以上代码的全部执行结果如下：
		自定义类型的结果是 type of a:main.newInt
		类型别名的结果是 type of b:int
		p1={张三 北京 18}
		p1=main.person{name:"张三", city:"北京", age:18}
		*main.person
		p2=&main.person{name:"张三", city:"北京", age:20}
		*main.person
		小王子 18

		user1=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}

		user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}

		阿奇 会汪汪汪~
		阿奇 会运动！

	*/

}