目录
结构体基础
1.结构体是值类型：在Go语言中，结构体是一种值类型，与数组和基本数据类型一样。当结构体被赋值给一个变量或传递给一个函数时，它的值会被复制一份。因此，对复制的结构体进行修改不会影响原来的结构体。
2.结构体可以定义方法：在Go语言中，结构体可以定义方法，方法是与特定类型关联的函数，可以访问和操作结构体的字段。方法的定义语法与函数类似，但需要在函数名前加上接收者，接收者可以是值类型或指针类型。
3.结构体的字段可以使用标签：在Go语言中，可以给结构体的字段加上一个标签（tag），用来描述该字段的一些元数据信息，比如字段名、数据类型、校验规则等。标签的内容可以通过反射机制进行读取和修改。
4.结构体可以进行序列化和反序列化：在Go语言中，结构体可以通过序列化和反序列化的方式进行数据的编码和解码。序列化是将数据结构转换成二进制格式的过程，反序列化是将二进制格式的数据解析成数据结构的过程。常用的序列化方式包括JSON、XML、Protobuf等。
5.结构体字段的命名规范：在Go语言中，结构体字段的命名规范是使用驼峰命名法，即首字母小写，每个单词的首字母大写。这种命名方式可以提高代码的可读性和可维护性。
在Go语言中，结构体是一种自定义的数据类型，它由一组数据字段组成，每个字段可以是任意类型。结构体可以用于描述一些复杂的数据结构，比如记录、链表、树等。
结构体的定义如下：
type StructName struct {
Field1 type1
Field2 type2
...
FieldN typeN
}
结构体示例
下面是一个结构体的示例：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
p := Person{
Name: "Tom",
Age: 20,
}
fmt.Println(p)
fmt.Printf("Name: %s, Age: %d\n", p.Name, p.Age)
}
在上面的示例中，我们定义了一个Person结构体，它包含两个字段：Name和Age。在main函数中，我们创建了一个Person类型的变量p，并初始化其Name和Age字段。最后，我们输出了这个变量的值，以及它的Name和Age字段的值。
为结构体定义方法
除了定义结构体之外，我们还可以为结构体定义方法。方法是一种与特定类型关联的函数，可以访问和操作结构体的字段。
下面是一个为Person结构体定义方法的示例：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func (p Person) SayHello() {
fmt.Printf("Hello, my name is %s, and I am %d years old.\n", p.Name, p.Age)
}
func main() {
p := Person{
Name: "Tom",
Age: 20,
}
p.SayHello()
}
在上面的示例中，我们为Person结构体定义了一个SayHello方法，该方法输出一个字符串，包含Person的Name和Age字段的值。在main函数中，我们创建了一个Person类型的变量p，并调用了它的SayHello方法。
组合结构体
Go语言中的结构体也可以通过组合来实现复用的功能，具体实现方法如下：
package main
import "fmt"
type Person struct {
Name string
Age int
}
type Student struct {
P Person // 组合了Person结构体
School string
}
func main() {
s := Student{
Person{"Tom", 18},
"High School",
}
fmt.Println(s.P.Name, s.P.Age, s.School) // 输出 Tom 18 High School
}
这段代码中定义了一个Person结构体，包含Name和Age两个字段，另外定义了一个Student结构体，它组合了Person结构体。在main函数中，我们通过构造函数创建了一个Student实例s，并访问了它的Name、Age和School字段，需要通过s.P来访问Person结构体中的字段。
通过组合其他结构体，子结构体可以复用父结构体中的字段和方法，但是它不会继承父结构体的特性和行为。与继承相比，组合更加灵活和简单，但也需要开发者更多的手动操作。
需要注意的是，Go语言中没有类的概念，因此结构体不是类，它不能实现继承和多态等面向对象的特性，而是一种数据类型的定义方式。
嵌套结构体
可以在结构体中嵌套另一个结构体，从而形成一个复合的结构体类型。嵌套结构体可以直接使用内部结构体的字段，也可以通过内部结构体名来访问内部结构体的字段。
例如：
package main
import "fmt"
type Address struct {
Province string
City string
}
type Person struct {
Name string
Age int
Address Address
}
func main() {
p := Person{Name: "Tom", Age: 18, Address: Address{Province: "Beijing", City: "Chaoyang"}}
fmt.Println(p.Name, p.Age, p.Address.Province, p.Address.City)
}指针结构体
结构体变量通常会占用比较大的内存空间，为了节省内存，可以使用指针结构体。指针结构体可以通过&操作符获取结构体变量的地址，并通过*操作符访问结构体变量的值。
例如：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func mian() {
p:= &Person{
Name: "Tom",
Age: 18,
}
fmt.Println((*p).Name, (*p).Age) // 输出：Tom 18
fmt.Println(p.Name, p.Age) // 输出：Tom 18
}匿名字段
可以将一个结构体类型作为另一个结构体类型的字段，这个字段就称为匿名字段。匿名字段的类型可以是任意类型，可以是基本类型、结构体类型、指针类型等。匿名字段可以直接访问内部结构体的字段，也可以通过内部结构体名来访问内部结构体的字段。
例如：
package main
import "fmt"
type Address struct {
Province string
City string
}
type Person struct {
Name string
Age int
Address
}
func main() {
p := Person{Name: "Tom", Age: 18, Address: Address{Province: "Beijing", City: "Chaoyang"}}
fmt.Println(p.Name, p.Age, p.Province, p.City)
}面向对象
Go语言虽然不是一种纯面向对象编程语言，但它提供了一些面向对象编程的基本特性，比如封装、继承和多态等。
封装
Go语言通过大写字母开头的字段或方法来实现封装，这些字段或方法可以在包外部访问。小写字母开头的字段或方法则只能在当前包内部访问。
例如：
package main
import "fmt"
type Person struct {
name string
age int
}
func (p *Person) SayHello() {
fmt.Println("Hello, my name is", p.name, ", I'm", p.age, "years old.")
}
func main() {
p := &Person{"Tom", 18}
p.SayHello()
}
在上面的代码中，我们定义了一个名为Person的结构体，它有两个字段name和age，并且定义了一个方法SayHello，用于打印个人信息。在main函数中，我们创建了一个Person对象p，并调用它的SayHello方法，输出了它的信息。
继承
Go语言不支持传统的继承方式，但是可以通过结构体组合的方式实现继承。具体来说，我们可以在一个结构体中包含另一个结构体，并通过嵌套结构体的方式来继承其字段和方法。
例如：
package main
import "fmt"
type Person struct {
name string
age int
}
func (p *Person) SayHello() {
fmt.Println("Hello, my name is", p.name, ", I'm", p.age, "years old.")
}
type Student struct {
Person
score int
}
func main() {
s := &Student{Person{"Tom", 18}, 90}
s.SayHello()
fmt.Println("My score is", s.score)
}
在上面的代码中，我们定义了两个结构体Person和Student，Student结构体包含了一个Person类型的字段，并且定义了一个自己的score字段。在main函数中，我们创建了一个Student对象s，并调用它的SayHello方法，输出了它的信息，然后输出了它的成绩。
多态
Go语言不支持传统的多态方式，但是可以通过接口实现多态。具体来说，我们可以定义一个接口，并让不同的结构体实现这个接口，从而实现多态。
例如：
package main
import "fmt"
type Animal interface {
Say()
}
type Cat struct{}
func (c *Cat) Say() {
fmt.Println("Meow!")
}
type Dog struct{}
func (d *Dog) Say() {
fmt.Println("Woof!")
}
func main() {
var a Animal
a = &Cat{}
a.Say()
a = &Dog{}
a.Say()
}
这段Go语言代码定义了一个Animal接口和两个实现了该接口的结构体：Cat和Dog。Animal接口中只有一个Say()方法。Cat和Dog分别实现了Say()方法并输出相应的声音。在main函数中，定义了一个a变量，类型为Animal接口。首先将a赋值为一个Cat结构体的指针，然后调用a的Say()方法输出"Meow!"。接着将a赋值为一个Dog结构体的指针，再次调用a的Say()方法输出"Woof!"。