struct.go

package main

import (
	"encoding/json"
	"fmt"
)

// 自定义类型
type MyInt int

// 类型别名
type MyIntAlis = int

// 自定义结构体,类似于java中的类
type Person struct {
	name, sex string
	age       int
}

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

// Dream Person做梦的方法
func (p Person) Dream() {
	fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
}

// 定义修改人名称的方法 *Person 为引用传递
func (p *Person) updatePerson(newName string) {
	p.name = newName
	fmt.Println("更新Person.name为", newName)
}

func (m MyInt) sayHello() {
	fmt.Println("say hello ")
}

// 构造函数
func newPerson(name, sex string, age int) *Person {
	return &Person{
		name, sex, age,
	}
}

type Address struct {
	province string
	city     string
}

// 嵌套结构体
type User struct {
	name    string
	gender  string
	address Address
	Address //匿名结构体
}

// 继承
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Println(a.name + "在移动")
}

type Dog struct {
	feet    string
	*Animal //继承动物
}

func (d *Dog) wang() {
	fmt.Println(d.name + "汪汪")
}

// JSON序列化
type Coin struct {
	Name string
}

type CoinArray struct {
	GroupName string
	Coins     []*Coin
}

// Student 学生
type Student struct {
	ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key
	Gender string //json序列化是默认使用字段名作为key
	name   string //私有不能被json包访问
}

func structCase() {
	fmt.Println("=====结构体=====")

	var mi MyInt = 1
	fmt.Println(mi)
	mi.sayHello()

	var mia MyIntAlis = 2
	fmt.Println(mia)

	var person Person
	person.name = "Jack"
	person.age = 10
	person.updatePerson("Tom")
	fmt.Println(person.name)

	//匿名结构体
	var user struct {
		Name string
		Age  int
	}
	user.Name = "Jack"
	user.Age = 20
	fmt.Println(user)

	//指针类型结构体
	var p2 = new(Person)
	p2.name = "测试"
	p2.age = 18
	fmt.Println(p2)

	var p4 Person
	fmt.Println("结构体初始化: ", p4)

	//键值对初始化
	p5 := Person{
		name: "a",
		age:  20,
	}
	fmt.Println(p5)

	//使用值列表初始化
	/**
	  1.必须初始化结构体的所有字段。
	  2.初始值的填充顺序必须与字段在结构体中的声明顺序一致。
	  3.该方式不能和键值初始化方式混用。
	*/
	p6 := Person{
		"e",
		"sex",
		1,
	}
	fmt.Println(p6)

	np := newPerson("name", "city", 11)
	fmt.Println(np.sex)

	//匿名结构体实例化
	anonymous := Anonymous{"str", 10}
	fmt.Println(anonymous.string)

	//实例化嵌套结构体
	u := User{
		name:   "jack",
		gender: "m",
		address: Address{
			province: "p",
			city:     "c",
		},
	}
	u.city = "c2" //当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找
	u.province = "c1"
	fmt.Println(u)

	dog := Dog{
		feet: "feet",
		Animal: &Animal{
			name: "dog",
		},
	}
	dog.move()
	dog.wang()

	//JSON序列化
	coinArray := CoinArray{
		GroupName: "conArray",
		Coins:     make([]*Coin, 0, 10),
	}

	coins := append(coinArray.Coins, &Coin{"BTC"})
	coins = append(coins, &Coin{"ETH"})
	coins = append(coins, &Coin{"SOL"})

	data, err := json.Marshal(coinArray)
	if err != nil {
		fmt.Println("json序列化失败")
	}
	fmt.Printf("json:%s\n", data)

	//反序列化
	coinArrayDeSer := &CoinArray{}
	err = json.Unmarshal([]byte(data), coinArrayDeSer)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Println(coinArrayDeSer)

	//结构体标签
	s1 := Student{
		ID:     1,
		Gender: "女",
		name:   "pprof",
	}
	dataa, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", dataa) //json str:{"id":1,"Gender":"女"}

}