Golang中的复合数据类型
4.结构体
1).关于Golang结构体
Golang中没有类的概念，Golang中的结构体和其他语言中的类有点相似。和其他面向对象语言中的类相比，Golang中的结构体具有更高的扩展性和灵活性
Golang中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，再使用但是的基本数据类型就无法满足需求了，Golang中提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。我们可以通过struct来定义自己的类型。
2).Golang type关键字自定义类型和类型别名
Golang中通过type关键字定义一个结构体
自定义类型
在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。
type myInt int
上面代码表示：将myInt定义为int类型，通过type关键字的定义，myInt就是一种新的类型，它具有int的特性。
类型别名
Golang1.9版本以后添加的新功能
类型别名规定：TypeAlias只是Type的别名，本质是TypeAlias与Type是同一个类型。
type TypeAlias = Type
3).结构体定义初始化的几种方法
结构体的定义
使用type和struct关键字来定义结构体，具体代码格式如下：
type 类型名 struct {
字段名 字段类型
字段名 字段类型
...
}
其中
- 类型名：表示自定义结构体的名称，在同一个包内不能重复
- 字段名：表示结构体字段名，结构体中的字段名必须唯一
- 字段类型：表示结构体字段的具体类型
结构体实例化（第一种方法）
只有当结构体实例化时，才会真正的分配内存，也就是必须实例化后才能使用结构体的字段。
结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型
var 结构体实例 结构体类型
结构体实例化（第二种方法）
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址
var 结构体实例 = new(结构体类型)
var p2 = new(Person)
p2.name = "lisi"
p2.age = 20
p2.sex = "Male"
注意：在Golang中支持对结构体指针直接使用.来访问结构体的成员。p2.name = "lisi" 其实在底层是(*p2).name = "lisi"
结构体实例化（第三种方法）
使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作
结构体实例化（第四种方法）
键值对初始化
var 结构体实例 = 结构体类型{
结构体属性: 属性对应值,
结构体属性: 属性对应值,
...
}
注意，最后一个属性的逗号(,)要加上
结构体实例化（第五种方法）
结构体指针进行键值对初始化
var 结构体实例 = &结构体类型{
结构体属性: 属性对应值,
结构体属性: 属性对应值,
...
}
当某些字段没有初始值的时候，这个字段可以不写。此时，没有指定初始值的字段的值为类型零值
结构体实例化（第六种方法）
使用值的列表初始化
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
结构体实例 := &结构体类型{
属性值，
属性值，
...
}
4).结构体方法和接收者
在Go语言中给，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。所谓方法就是定义了接收这的函数。接收者的概念就类似于其他语言中的this或者self。
方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表)(返回参数){
函数体
}
其中
- 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。列如，Person类型的接收者变量应该命名为p，Connector类型的接收者变量名应该命名为c等。
- 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
- 方法名、参数列表、返回参数：具体格式与函数定义相同。
5).给任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。
6).结构体的匿名字段
结构体允许其成员变量在声明是没有字段名只有类型，这种没有字段名字的字段就称为匿名字段
7).嵌套结构体
结构体的字段类型可以是：基本数据类型，也可以是切片、map 以及结构体
如果结构体的字段类型是：指针、slice、和map的零值都是nil，即还没有分配空间
如果需要使用这样的字段，就要先make，才能使用
8).嵌套匿名结构体
注意：当访问结构体成员时，会先在结构体中查找该字段，找不到再去匿名结构体中查找。
9).关于嵌套结构体的字段名冲突
嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义，需要指定具体的内嵌结构体的字段
10).结构体的继承
Go语言中使用结构体也可以实现其他编程语言中的继承
一个结构体中可以嵌套包含另一个结构体或者结构体指针
Golang结构体和Json相互转换 序列化 反序列化
1.关于JSON数据
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。易于人阅读和编写，同时也易于机器解析和生成。RESTful API 接口中返回的数据都是json数据
2.结构体与JSON序列化
如果Golang要给App或者小程序提供API接口数据，就需要涉及到结构体和json之间的相互转换
Golang JSON序列化是指把结构体数据转化成JSON格式的字符串，Golang JSON 的反序列化是指把JSON数据转化成Golang中的结构体对象
Golang中的序列化和反序列化主要通过"encoding/json"包中的json.Marshal()和json.Unmarshal()方法实现。
3.结构体标签Tag
Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：
`key1:"value1" key2:"value2"`
结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。
注意事项：为结构体编写tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误信息，通过反射也无法正确取值。例如不要再key和value之间添加空格。
4.嵌套结构体和JSON序列化反序列化
4.关于Map、切片的序列化反序列化
Map和切片也可以进行序列化和反序列化，在学习接口之后再详细学习。
代码：
package main
import (
"fmt"
"encoding/json"
)
//自定义类型
type MyInt int
//注意：非本地类型不能定义方法，也就是不能给别的包的类型定义方法
func (m MyInt) PrintInfo() {
fmt.Println("我是自定义类型的自定义方法")
}
type myFn func(int, int) int
//类型别名
type myFloat = float64
//注意：结构体首字母可以大写也可以小写，大写表示这个结构体是公有的，在其他的包里面可以使用，小写表示这个结构体是私有的，只有这个包里面才能使用
type Person struct {
name string
age int
sex string
}
func (p Person) PrintInfo() {
fmt.Printf("name:%v, age:%v", p.name, p.age)
}
//想要修改结构体的属性值，接收体类型必须是结构体指针
func (p *Person) SetInfo(name string, age int) {
p.name = name
p.age = age
}
type Student struct {
name string
age int
sex string
}
/*
结构体的匿名字段：
结构体允许其成员变量在声明是没有字段名只有类型，这种没有字段名字的字段就称为匿名字段
匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个
*/
type Teacher struct {
string
int
}
/*
嵌套结构体
结构体的字段类型可以是：基本数据类型，也可以是切片、map 以及结构体
如果结构体的字段类型是：指针、slice和map的零值都是nil，即还没有分配空间
如果需要使用这样的字段，就要先make，才能使用
*/
type Driver struct {
Name string
Age int
Hobby []string
map1 map[string]string
}
type User struct {
Username string
Password string
Address Address //User结构体嵌套Address结构体
}
type Address struct {
Name string
Phone string
City string
}
/*
嵌套匿名结构体
*/
type Customer struct {
Username string
Password string
Address
}
//嵌套结构体的字段名冲突
type Client struct {
Username string
Password string
Addtime string
Contact
}
type Contact struct {
Name string
Phone string
City string
Addtime string
}
type Employee struct {
Username string
Password string
Contact
Email
}
type Email struct {
Account string
Addtime string
}
//结构体的继承
//一个结构体中可以嵌套包含另一个结构体或者结构体指针
//父结构体
type Animal struct {
Name string
}
func (a Animal) run(){
fmt.Printf("%v 在运动
", a.Name)
}
//子结构体
type Dog struct{
Age string
Animal //结构体嵌套 继承
}
func (d Dog) shout(){
fmt.Printf("%v 在旺旺
", d.Name)
}
type Cat struct{
Age string
*Animal //结构体嵌套 继承
}
func (c Cat) shout(){
fmt.Printf("%v 在旺旺
", c.Name)
}
//json序列化
type Professor struct {
ID int `json:"id"` //通过指定tag实现json序列化该字段时的key
Gender string `json:"gender"`
// name string//私有属性不能被json包访问
Name string `json:"name"`
Pno string `json:"pno"`
}
type Learner struct {
Id int
Gender string
Name string
}
type Class struct {
Title string
Learners []Learner
}
func main() {
//结构体
//类型别名
// var a myInt = 10
// fmt.Printf("%v %T
", a, a)//10 main.myInt
// var b myFloat = 10.3
// fmt.Printf("%v %T
", b, b)//10。3 float64
//
// var p1 Person //实例化Person结构体
// p1.name = "zhangsan"
// p1.age = 20
// p1.sex = "Male"
// fmt.Printf("值:%v 类型：%T
", p1, p1)//值:{zhangsan 20 Male} 类型：main.Person
// //使用%#v打印结构体具体信息
// fmt.Printf("值:%#v 类型：%T", p1, p1)//值:main.Person{name:"zhangsan", age:20, sex:"Male"} 类型：main.Person
//注意：在Golang中支持对结构体指针直接使用.来访问结构体的成员。p2.name = "lisi" 其实在底层是(*p2).name = "lisi"
// var p2 = new(Person)
// p2.name = "lisi"
// p2.age = 20
// p2.sex = "Male"
// fmt.Printf("值:%#v 类型：%T
", p2, p2)//值:&main.Person{name:"lisi", age:20, sex:"Male"} 类型：*main.Person
// (*p2).name = "wangwu"
// fmt.Printf("值:%#v 类型：%T
", p2, p2)//值:&main.Person{name:"wangwu", age:20, sex:"Male"} 类型：*main.Person
// var p3 = &Person{}
// p3.name = "zhaoliu"
// p3.age = 23
// p3.sex = "Male"
// fmt.Printf("值:%#v 类型：%T
", p3, p3) //值:&main.Person{name:"zhaoliu", age:23, sex:"Male"} 类型：*main.Person
// var p4 = Person{
// name: "test",
// age: 20,
// sex: "Female",
// }
// fmt.Printf("值:%#v 类型：%T
", p4, p4)//值:main.Person{name:"test", age:20, sex:"Female"} 类型：main.Person
// var p5 = &Person{
// name: "Tom",
// age: 20,
// sex: "Female",
// }
// fmt.Printf("值:%#v 类型：%T
", p5, p5)//值:&main.Person{name:"Tom", age:20, sex:"Female"} 类型：*main.Person
// var p6 = &Person{
// name: "Jerry",
// }
// fmt.Printf("值:%#v 类型：%T
", p6, p6)//值:&main.Person{name:"Jerry", age:0, sex:""} 类型：*main.Person
// var p7 = &Person{
// "hana",
// 25,
// "Female",
// }
// fmt.Printf("值:%#v 类型：%T
", p7, p7)//值:&main.Person{name:"hana", age:25, sex:"Female"} 类型：*main.Person
//结构体方法和接收者
// var s1 = Student {
// name: "ash",
// age: 27,
// sex: "Female",
// }
// s2 := s1
// s2.name = "hana"
// fmt.Printf("%#v
",s1)//main.Student{name:"ash", age:27, sex:"Female"}
// fmt.Printf("%#v
",s2)//main.Student{name:"hana", age:27, sex:"Female"}
// //结构体是值类型
// var p = Person{
// name: "zhangsan",
// age: 20,
// sex: "Male",
// }
// p.PrintInfo()//name:zhangsan, age:20
// fmt.Println()
// var pp = Person{
// name: "lisi",
// age: 20,
// sex: "Male",
// }
// pp.PrintInfo()//name:lisi, age:20
// fmt.Println()
// p.PrintInfo()//name:zhangsan, age:20
//Golang中结构体实例是独立的，不会相互影响
// fmt.Println()
// p.SetInfo("wangwu",11)
// p.PrintInfo()//name:wangwu, age:11
// fmt.Println()
// pp.PrintInfo()//name:lisi, age:20
// var myInt MyInt
// myInt.PrintInfo()
//匿名结构体
// t := Teacher {
// "zhangsan",
// 30,
// }
// fmt.Println(t)//{zhangsan 30}
//嵌套结构体
// var d Driver
// d.Name = "lisi"
// d.Age = 30
// d.Hobby = make([]string, 3, 6)
// d.Hobby[0] = "drive"
// d.Hobby[1] = "sport"
// d.Hobby[2] = "sleep"
// d.map1 = make(map[string]string)
// d.map1["address"] = "beijing"
// d.map1["phone"] = "12345678901"
// // fmt.Printf("%#v",d)//main.Driver{Name:"lisi", Age:30, Hobby:[]string{"drive", "sport", "sleep"}, map1:map[string]string{"address":"beijing", "phone":"12345678901"}}
// fmt.Printf("%v", d.Hobby) //[drive sport sleep]
// var u User
// u.Username = "hana"
// u.Password = "123456"
// u.Address.Name = "zhangsan"
// u.Address.Phone = "12343879609"
// u.Address.City = "chengdu"
// fmt.Printf("%#v", u)//main.User{Username:"hana", Password:"123456", Address:main.Address{Name:"zhangsan", Phone:"12343879609", City:"chengdu"}}
//嵌套匿名结构体
// var c Customer
// c.Username = "hana"
// c.Password = "123456"
// c.Address.Name = "zhangsan"
// c.Address.Phone = "12343879609"
// c.Address.City = "chengdu"
// // fmt.Printf("%#v
", c)//main.Customer{Username:"hana", Password:"123456", Address:main.Address{Name:"zhangsan", Phone:"12343879609", City:"chengdu"}}
// c.City = "ShangHai"//当访问结构体成员时，会先在结构体中查找该字段，找不到再去匿名结构体中查找。
// fmt.Printf("%#v
", c)//main.Customer{Username:"hana", Password:"123456", Address:main.Address{Name:"zhangsan", Phone:"12343879609", City:"ShangHai"}}
// fmt.Println(c.Address.Phone)//12343879609
// fmt.Println(c.Phone)//12343879609
//关于嵌套结构体的字段名冲突
// var c Client
// c.Username = "wangwu"
// c.Password = "123456"
// c.Contact.Name = "zhangsan"
// c.Contact.Phone = "12343879609"
// c.Contact.City = "chengdu"
// c.City = "ShenZhen"
// c.Addtime = "2020-10-09"
// fmt.Printf("%#v
", c)//main.Client{Username:"wangwu", Password:"123456", Addtime:"2020-10-09", Contact:main.Contact{Name:"zhangsan", Phone:"12343879609", City:"ShenZhen", Addtime:""}}
// c.Contact.Addtime = "2020-10-10"
// fmt.Printf("%#v
", c)//main.Client{Username:"wangwu", Password:"123456", Addtime:"2020-10-09", Contact:main.Contact{Name:"zhangsan", Phone:"12343879609", City:"ShenZhen", Addtime:"2020-10-10"}}
// var e Employee
// e.Username = "wangwu"
// e.Password = "123456"
// e.Contact.Name = "zhangsan"
// e.Contact.Phone = "12343879609"
// e.Contact.City = "chengdu"
// e.City = "ShangHai"
// // e.Addtime = "2020-10-09"//ambiguous selector e.Addtime
// e.Contact.Addtime = "2020-10-09"
// e.Email.Addtime = "2020-10-10"
// fmt.Printf("%#v
", e)//main.Employee{Username:"wangwu", Password:"123456", Contact:main.Contact{Name:"zhangsan", Phone:"12343879609", City:"ShangHai", Addtime:"2020-10-09"}, Email:main.Email{Account:"", Addtime:"2020-10-10"}}
// var d = Dog{
// Age: "20",
// Animal: Animal{
// Name: "daqing",
// },
// }
// d.run()//daqing 在运动
// d.shout()//daqing 在旺旺
var c = Cat{
Age: "20",
Animal: &Animal{
Name: "weiwei",
},
}
c.run()//weiwei 在运动
c.shout()//weiwei 在旺旺
//结构体转json
// var p1 = Professor{
// ID: 11,
// Gender: "Male",
// Name: "Tom",
// Pno: "p0001",
// }
// fmt.Printf("%#v
",p1)//main.Professor{ID:11, Gender:"Male", Name:"Tom", Pno:"p0001"}
// var jsonByte, _ = json.Marshal(p1)
// jsonStr := string(jsonByte)
// fmt.Printf("%v",jsonStr)//{"ID":11,"Gender":"Male","Name":"Tom","Pno":"p0001"}
//json转结构体
// var str = `{"ID":11,"Gender":"Male","Name":"Tom","Pno":"p0001"}`
// var p2 Professor
// err := json.Unmarshal([]byte(str), &p2)
// if err != nil {
// fmt.Println(err)
// }
// fmt.Printf("%#v
", p2) //main.Professor{ID:11, Gender:"Male", Name:"Tom", Pno:"p0001"}
// fmt.Println(p2.Name) //Tom
//结构体标签
// var p3 = Professor{
// ID: 11,
// Gender: "Male",
// Name: "Tom",
// Pno: "p0001",
// }
// var jsonByte, _ = json.Marshal(p3)
// jsonStr := string(jsonByte)
// fmt.Printf("%v",jsonStr)//{"id":11,"gender":"Male","name":"Tom","pno":"p0001"}
//嵌套结构体和JSON序列化反序列化
// c := Class{
// Title: "001",
// Learners: make([]Learner, 0, 200),
// }
// for i := 0; i < 10; i++ {
// l := Learner{
// Id: i,
// Gender: "Male",
// Name: fmt.Sprintf("learn_%v", i),
// }
// c.Learners = append(c.Learners, l)
// }
// fmt.Printf("%#v
", c) //main.Class{Title:"001", Learners:[]main.Learner{main.Learner{Id:0, Gender:"Male", Name:"learn_0"}, main.Learner{Id:1, Gender:"Male", Name:"learn_1"}, main.Learner{Id:2, Gender:"Male", Name:"learn_2"}, main.Learner{Id:3, Gender:"Male", Name:"learn_3"}, main.Learner{Id:4, Gender:"Male", Name:"learn_4"}, main.Learner{Id:5, Gender:"Male", Name:"learn_5"}, main.Learner{Id:6, Gender:"Male", Name:"learn_6"}, main.Learner{Id:7, Gender:"Male", Name:"learn_7"}, main.Learner{Id:8, Gender:"Male", Name:"learn_8"}, main.Learner{Id:9, Gender:"Male", Name:"learn_9"}}}
// strByte, err := json.Marshal(c)
// if err != nil {
// fmt.Println(err)
// } else {
// strJson := string(strByte)
// fmt.Println(strJson)//{"Title":"001","Learners":[{"Id":0,"Gender":"Male","Name":"learn_0"},{"Id":1,"Gender":"Male","Name":"learn_1"},{"Id":2,"Gender":"Male","Name":"learn_2"},{"Id":3,"Gender":"Male","Name":"learn_3"},{"Id":4,"Gender":"Male","Name":"learn_4"},{"Id":5,"Gender":"Male","Name":"learn_5"},{"Id":6,"Gender":"Male","Name":"learn_6"},{"Id":7,"Gender":"Male","Name":"learn_7"},{"Id":8,"Gender":"Male","Name":"learn_8"},{"Id":9,"Gender":"Male","Name":"learn_9"}]}
// }
str := `{"Title":"001","Learners":[{"Id":0,"Gender":"Male","Name":"learn_0"},{"Id":1,"Gender":"Male","Name":"learn_1"},{"Id":2,"Gender":"Male","Name":"learn_2"},{"Id":3,"Gender":"Male","Name":"learn_3"},{"Id":4,"Gender":"Male","Name":"learn_4"},{"Id":5,"Gender":"Male","Name":"learn_5"},{"Id":6,"Gender":"Male","Name":"learn_6"},{"Id":7,"Gender":"Male","Name":"learn_7"},{"Id":8,"Gender":"Male","Name":"learn_8"},{"Id":9,"Gender":"Male","Name":"learn_9"}]}`
var c = &Class{}
err := json.Unmarshal([]byte(str),c)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("%#v
",c)//&main.Class{Title:"001", Learners:[]main.Learner{main.Learner{Id:0, Gender:"Male", Name:"learn_0"}, main.Learner{Id:1, Gender:"Male", Name:"learn_1"}, main.Learner{Id:2, Gender:"Male", Name:"learn_2"}, main.Learner{Id:3, Gender:"Male", Name:"learn_3"}, main.Learner{Id:4, Gender:"Male", Name:"learn_4"}, main.Learner{Id:5, Gender:"Male", Name:"learn_5"}, main.Learner{Id:6, Gender:"Male", Name:"learn_6"}, main.Learner{Id:7, Gender:"Male", Name:"learn_7"}, main.Learner{Id:8, Gender:"Male", Name:"learn_8"}, main.Learner{Id:9, Gender:"Male", Name:"learn_9"}}}
fmt.Println(c.Title)//001
}
}