1. 字段加 tag ，该 tag 可通过反射机制获取，常见的使用场景就是序列化和反序列化。

    func Marshal(v interface{}) ([]byte, error)
    Marshal函数返回v的json编码。

    1. package main
    3. import (
    4.     "encoding/json"
    5.     "fmt"
    6. )
    8. type A struct {
    9.     Num int
    10. }
    12. type B struct {
    13.     Num int
    14. }
    16. type Monsters struct {
    17.     // 字段必须大写，否则当使用别包的方法 json.Marshal 序列化的时候，读不到字段信息
    18.     // 前端使用者，通常使用小写的字段名,
    19.     // 这就需要通过 tag 来转化大写的字段，同时又保证内部调用的时候可以暴露变量
    20.     // 反射原理
    21.     Name  string `json:"name"`
    22.     Age   int    `json:"age"`
    23.     Skill string `json:"skill"`
    24. }
    26. func main() {
    27.     // 结构体转化，必须字段和类型全部一致，才可以转化
    28.     var a A
    29.     var b B
    30.     a = A(b)
    31.     fmt.Println(a, b) // {0} {0}
    33.     // 后端开发者： 结构体序列化
    34.     monster := Monsters{"小牛", 3, "芭蕉扇"}
    35.     // 将monster变量序列化为json字符串格式
    36.     monsterStr, err := json.Marshal(monster)
    37.     if err != nil {
    38.         fmt.Println("json 序列化失败", err)
    39.     }
    40.     fmt.Printf("monsterStr = %s \n", monsterStr)     // {"Name":"小牛","Age":3,"Skill":"芭蕉扇"}
    41.     fmt.Println("monsterStr = ", string(monsterStr)) // {"Name":"小牛","Age":3,"Skill":"芭蕉扇"}
    43.     // 前端使用者，通常使用小写的字段名  Name  string `json:"name"`
    44.     // 输出： {"name":"小牛","age":3,"skill":"芭蕉扇"}
    45. }
    1. 结构体的所有字段在内存中是连续的

    结构体嵌套
    image.png

    1. 结构体类型相互转化的时候，需要有完全相同的字段（名字、个数、类型）
    2. 结构体进行type重新定义（相当于起别名），Golang认为是新的数据类型，但是可以强转。 ```go type Person struct { Name string Age int } type People Person type integer int

    func main () { // 结构体类型转化 var p5 Person var people1 People // people1 = p5 // 错误 people1 = People(p5) // 强转类型 fmt.Println(“people1 = “, people1) // people1 = { 0}

    var n1 integer = 20 var n2 int = 20 // n1 = n2 // 错误 integer 和 int golang认为不是同一个类型 fmt.Printf(“n1 类型： %T, 值： %v \n”, n1, n1) // n1 类型： main.integer, 值： 20 fmt.Printf(“n2 类型： %T, 值： %v \n”, n2, n2) // n2 类型： int, 值： 20 }

    ```