package main

import (
	"fmt"
)

// 用二维数组定义人的集合
var Persons [][]interface{}

// 可以用结构体来实现这种功能
// 定义结构体
type Person struct {
	Name    string
	Age     int
	Address string
	Height  float64
}

type User struct {
	Name string
	Age  int
}

/**
 * 结构体嵌套
 */
// 第一种结构体嵌套的方式
type Student1 struct {
	user  User
	score float64
}

// 第二种结构体嵌套的方式：匿名嵌套
type Student2 struct {
	User
	score float64
}

// 第三种结构体嵌套的方式：匿名嵌套 + 覆盖
type Student3 struct {
	User
	score float64
	Name  string
}

// 第四种结构体嵌套
type Student4 struct {
	Name    string
	Age     int
	Address struct {
		Province string
		City     string
		Street   string
	}
}

/**
 * 为结构体绑定方法：
 *
 * 格式1（值传递）：func (s structType) funcName(param1 param1Type, ...) (returnVal1 Type1, ...) { ... }
 *                             ↑           ↑       ↑                        ↑                      ↑
 *                      接收器（值传递）  方法名  方法参数                 方法返回值                方法体
 *
 * 格式2（引用传递）：func (s *structType) funcName(param1 param1Type, ...) (returnVal1 Type1, ...) { ... }
 *                             ↑             ↑       ↑                         ↑                     ↑
 *                      接收器（引用传递）  方法名  方法参数                  方法返回值               方法体
 */
// 注意：前面的 (p Person) 并不是方法的参数，而是绑定的结构体的类型和变量，也叫“接收器”
// go对结构体的指针做了优化：无论接收器是值类型还是指针类型，都可以接收并正确使用值传递类型
func (p *Person) GetName() string {
	// 如果希望改变p的值，那么只能通过引用传递才能实现
	p.Age = 22
	return p.Name
}

func main() {
	// 如果不使用结构体，那么保存Person的信息会比较麻烦
	Persons = append(Persons, []interface{}{"lixingyun", 19, "china", 1.81})

	// 创建并向结构体中保存数据
	// 在同一行中赋值
	person1 := Person{"lixingyun", 19, "china", 1.81}
	// 在不同的行中赋值
	person2 := Person{
		Name:    "lixingyun",
		Age:     19,
		Address: "china",
		Height:  1.81,
	}
	// 也可以只初始化需要的字段
	person3 := Person{
		Name:    "lixingyun",
		Address: "china",
	}

	// 保存person数据
	var persons1 []Person
	// 第一种保存方式
	persons1 = append(persons1, person1, person2, person3)
	// 第二种保存方式
	persons1 = append(persons1, Person{
		Name:   "lixingyun",
		Height: 1.81,
	})
	// 第三种保存方式：一次初始化多个Person
	persons2 := []Person{
		{
			Name:    "lixingyun",
			Address: "china",
		},
		{
			Name:   "lixingyun",
			Height: 1.81,
		},
		{
			Age:     19,
			Address: "china",
		},
	}
	fmt.Println(persons2)
	// 第四种保存方式：一次初始化一个Person
	var person4 Person
	person4.Name = "lixingyun"
	person4.Age = 19
	person4.Height = 1.81
	fmt.Println(person4)
	// 第五种保存方式：一次初始化一个Person
	person5 := Person{}
	person5.Name = "wanglin"
	fmt.Println(person5)

	// 匿名结构体
	address := struct {
		Province string
		City     string
		Street   string
	}{
		Province: "beijing",
		City:     "beijing",
		Street:   "changan",
	}
	fmt.Println(address)

	// 使用第一种结构体嵌套
	stu1 := Student1{
		user: User{
			Name: "lixingyun",
		},
		score: 100,
	}
	stu1.user.Age = 20
	fmt.Println(stu1)

	// 使用第二种结构体嵌套
	stu2 := Student2{}
	stu2.Name = "lixingyun"
	stu2.Age = 19
	stu2.score = 100
	fmt.Println(stu2)

	// 使用第三种结构体嵌套
	stu3 := Student3{
		User{
			Name: "lixingyun",
			Age:  19,
		},
		100,
		"wanglin",
	}
	// 设置的是外层的字段，外层字段的优先级比匿名结构体高
	stu3.Name = "xiaoyan"
	fmt.Println(stu3)

	// 调用结构体定义的方法，就等同于调用“类”的方法
	person6 := Person{
		Name: "lixingyun",
	}
	// 这种调用方式等同于 print(p)
	fmt.Println(person6.GetName())
	fmt.Println(person6)
}