Go没有沿袭传统面向对象编程中的诸多概念，也没有提供类(class)，但是它提供了结构体(struct)，方法(method)可以在结构体上添加。与类相似，结构体提供了捆绑数据和方法的行为。

1. 介绍

1.1 概念

单一的数据类型已经满足不了现实开发需求，于是 Go 语言提供了结构体来定义复杂的数据类型。结构体是由一系列相同类型或不同类型的数据构成的数据集合。结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存。因此必须在定义结构体并实例化后才能使用结构体的字段。

1.2 语法

type 类型名称 struct {
   field type
   field type 
   field1,field2,field3 type // 同类型变量可以写在一行
}

1.3 注意事项

类型名是标识结构体的名称，在同一个包内不能重复。
结构体的属性，也叫字段(field)，必须唯一。
同类型的成员属性可以写在一行。
结构体是值类型。
只有当结构体实例化时,才能使用结构体的字段。

2. 实例化

2.1 使用var

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 // 使用var 实例化结构体
 var s student
 fmt.Printf("变量s--> 类型: %T 值: %v \n",s,s)
 // 给属性赋值
 s.name = "张三"
 s.age = 20
 s.like = []string{"打游戏","看动漫"}
 fmt.Printf("给属性赋值: 变量s--> 类型: %T 值: %v \n",s,s)
}
/*输出
变量s--> 类型: main.student 值: { 0 []} 
给属性赋值: 变量s--> 类型: main.student 值: {张三 20 [打游戏 看动漫]} 
*/

3.2 使用简短声明 (:=)

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 // 方式一: 先实例化结构体，后赋值
 s := student{}
 // 给属性赋值
 s.name = "张三"
 s.age = 20
 s.like = []string{"打游戏","看动漫"}
 fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)

 // 方式二: 声明时初始化
 s1 := student{
  name: "李四",
  age:  23,
  like: []string{"旅游","运动"},
 }
 fmt.Printf(" 变量s1--> 类型: %T 值: %v \n",s1,s1)

 // 方式三: 声明时初始化，省略属性
 s2 := student{"王麻子",30,[]string{"睡觉","吃饭"}}
 fmt.Printf(" 变量s2--> 类型: %T 值: %v \n",s2,s2)
}
/**输出
 变量s--> 类型: main.student 值: {张三 20 [打游戏 看动漫]} 
 变量s1--> 类型: main.student 值: {李四 23 [旅游 运动]} 
 变量s2--> 类型: main.student 值: {王麻子 30 [睡觉 吃饭]} 
*/

3.3 使用new

使用内置函数new()对结构体进行实例化，结构体实例化后形成指针类型的结构体，new()内置函数会分配内存。第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针。

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 // 使用new实例化
 s := new(student)
 fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
 // 给属性赋值
 (*s).name = "包青天"
 (*s).age = 55
 (*s).like = []string{"判案"}
 fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
 // 语法糖写法(省略*)
 s.name = "包大人"
 s.age = 99
 s.like = []string{"判案","元芳你怎么看"}
 fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
}
/**输出
 变量s--> 类型: *main.student 值: &{ 0 []} 
 变量s--> 类型: *main.student 值: &{包青天 55 [判案]} 
 变量s--> 类型: *main.student 值: &{包大人 99 [判案 元芳你怎么看]} 
*/

3. 结构体在函数中使用

结构体作为函数参数，若复制一份传递到函数中，在函数中对参数进行修改，不会影响到实际参数，证明结构体是值类型。

3.1 传结构体值作为参数

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 s := student{name:"张三",age:17}
 fmt.Printf(" 变量s--> 值: %v \n",s)
 grownUp(s)
 fmt.Printf("调用函数后,变量s--> 值: %v \n",s)
}
// 传结构体值作为参数
func grownUp( s student)  {
 s.age = 80
 s.name = "长大的 "+s.name
}
/**输出
 变量s--> 值: {张三 17 []} 
 调用函数后,变量s--> 值: {张三 17 []} 
*/

3.2 传结构体指针作为参数

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 s := student{name:"张三",age:17}
 fmt.Printf(" 变量s--> 值: %v \n",s)
  // 取址
 grownUp(&s)
 fmt.Printf("调用函数后,变量s--> 值: %v \n",s)
}
// 传结构体指针作为参数
func grownUp( s *student)  {
 s.age = 80
 s.name = "长大的 "+s.name
}
/** 输出:
 变量s--> 值: {张三 17 []} 
 调用函数后,变量s--> 值: {长大的 张三 80 []} 
*/

3.3 返回对象

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 s := getStudent("杨过",40,[]string{"骑大雕"})
 fmt.Printf("函数返回值 s--> 值: %v  类型: %T \n",s,s)
}
// 作为值类型传递
func getStudent( name string, age int,likes []string) student  {
 return student{name,age,likes}
}
// 函数返回值 s--> 值: {杨过 40 [骑大雕]}  类型: main.student

3.4 返回指针

package main
import "fmt"
// 定义结构体
type student struct {
 name string
 age int
 like []string
}
func main() {
 s := getStudent("杨过",40,[]string{"骑大雕"})
 fmt.Printf("函数返回值 s--> 值: %v  类型: %T \n",s,s)
}

// 返回指针
func getStudent( name string, age int,likes []string) *student  {
 return &student{name,age,likes}
}
// 输出: 函数返回值 s--> 值: &{杨过 40 [骑大雕]}  类型: *main.student

4.匿名结构体

4.1 语法

变量名 := struct {
  // 定义成员属性
} { /*初始化成员属性*/ }

4.2 使用

package main
import "fmt"
func main() {
 // 声明初始化匿名结构体
 s := struct {
  name, home, phone string
  age               int
 }{
  name:  "张二十",
  phone: "17600111111",
  age:   18,
 }
  // 打印
 fmt.Printf("变量 s--> 值: %v  类型: %T \n", s, s)
}
// 输出: 变量 s--> 值: {张二十  17600111111 18}  类型: struct { name string; home string; phone string; age int }

5.匿名字段

5.1 定义

匿名字段就是在结构体中的字段没有名字，只包含一个没有字段名的类型。这些字段被称为匿名字段。在同一个结构体中,同一个类型只能有一个匿名字段。

5.2 使用

package main
import "fmt"
type people struct {
 name, home string
 int        // 匿名字段
 float32    // 匿名字段
}
func main() {
 // 声明初始化匿名结构体
 s := people{name: "张三", home: "北京", int: 18, float32: 1.73}
 fmt.Printf("变量 s--> 值: %v \n", s)
 // 声明初始化匿名结构体(省略属性名)
 s2 := people{"李四", "南京", 22, 1.80}
 fmt.Printf("变量 s2--> 值: %v \n", s2)
}
/** 输出
  变量 s--> 值: {张三 北京 18 1.73} 
  变量 s2--> 值: {李四 南京 22 1.8} 
*/

6. 结构体嵌套

6.1 定义

将一个结构体作为另一个结构体的属性（字段），这种结构就是结构体嵌套。

结构体嵌套可以模拟面向对象编程中的以下两种关系。

聚合关系: 一个类作为另一个类的属性。
继承关系: 一个类作为另一个类的子类。子类和父类的关系。

6.2 聚合场景

模拟聚合关系时一定要采用有名字的结构体作为字段。

package main
import "fmt"
// 定义学生结构体
type student struct {
 name       string
 height      float32
 schoolInfo  school
}
// 定义学习结构体
type school struct {
 schoolName, schoolAddress string
}
func main() {
 // 简短声明嵌套结构体
 s := student{"小张",1.72,school{"北京大学","北京"}}
 fmt.Printf("变量 s--> 值: %v 类型: %T \n", s,s)
 // 使用var
 var ss student
 ss.name = "小龙"
 ss.height = 1.67
 ss.schoolInfo = school{"南京大学","南京"}
 fmt.Printf("变量 ss--> 值: %v 类型: %T \n", ss,ss)
 // 使用new
 s2 := new(student)
 s2.name = "小虎"
 s2.height = 1.77
 s2.schoolInfo.schoolName = "武汉大学"
 s2.schoolInfo.schoolAddress = "武汉"
 fmt.Printf("变量 s2--> 值: %v 类型: %T \n", s2,s2)
}
/** 输出:
  变量 s--> 值: {小张 1.72 {北京大学 北京}} 类型: main.student 
  变量 ss--> 值: {小龙 1.67 {南京大学 南京}} 类型: main.student 
  变量 ss--> 值: &{小虎 1.77 {武汉大学 武汉}} 类型: *main.student 
*/

6.3 模拟继承

在结构体中，属于匿名结构体的字段称为提升字段，它们可以被访问，匿名结构体就像是该结构体的父类。

package main
import "fmt"

// 定义父类结构体
type people struct {
 name  string
 age   int
}
type student struct {
 people // 集成父类结构体
 class string
}

func main() {
 // 方式1.使用new声明结构体
 var s = new(student)
 // 集成父类成员
 s.name = "张三"
 s.age = 12
 // 自己成员
 s.class = "三年级"
 fmt.Printf("变量s -> %v \n",s)
 // 方式2.使用简短声明
 s2 := student{people{"李四",13},"四年级"}
 fmt.Printf("变量s2 -> %v \n",s2)
}
/** 输出
变量s -> &{{张三 12} 三年级} 
变量s2 -> {{李四 13} 四年级} 
*/

6.4 成员冲突

package main
import "fmt"
type A struct {
 name string
 age  int
}
type B struct {
 name   string
 height float32
}
// 在C结构体中嵌套A和B
type C struct {
 A
 B
}
func main() {
 // 定义结构体C
 c := C{}
 // 不冲突的成员赋值
 c.age = 12
 c.height = 1.88
 // 冲突的成员赋值
 c.A.name = "这是A的成员"
 c.B.name = "这是B的成员"
 fmt.Printf("变量c -> %v \n", c)
}
// 输出: 变量c -> {{这是A的成员 12} {这是B的成员 1.88}}