type Person struct {

	Name string

	Age int

}

func main() {

	// 方式1

	var p Person

	fmt.Println(p)  // { 0}

	var p1 = Person{}

	p1.Name = "a"

	p1.Age = 1

	fmt.Println(p1) // {a 1}

	// 方式2

	var p2 = Person{"b", 2}

	var p3 = Person{

		Name: "b",

		Age: 2,

	}

	p4 := Person{"b", 2}

	p5 := Person{

		Name: "b",

		Age: 2,

	}

	fmt.Println(p2, p3, p4, p5) // {b 2} {b 2} {b 2} {b 2}

	// 方式3

	var p6 = new(Person) // var p6 *Person = new(Person)

	/*

	go的设计者，为了程序员的使用方便，底层会对 p6.Name = "c"进行处理，

	相当于*(p6).Name = "c"

	*/

	p6.Name = "c"	 // *(p6).Name = "c"

	p6.Age = 3   	 // *(p6).Age = 3

	fmt.Println(p6)  // &{c 3}

	fmt.Println(*p6) // {c 3}

	// 方式4（同方式3）

	var p7 = &Person{}

	p7.Name = "d"

	p7.Age = 4

	fmt.Println(p7, *p7)   // &{d 4} {d 4}

	var p8 = &Person{"e", 5}

	fmt.Println(p8, *p8)   // &{e 5} {e 5}

	p9 := &Person{}

	p9.Name = "f"

	p9.Age = 6

	fmt.Println(p9, *p9)   // &{f 6} {f 6}

	p10 := &Person{"g", 7}

	fmt.Println(p10, *p10) // &{g 7} {g 7}

}

type Person struct {

	Name string

	Age int

	Score [3]float64

	ptr *int

	s []int

	m map[string]string

}

func main() {

	var p Person

	fmt.Println(p) // { 0 [0 0 0] <nil> [] map[]}

	if p.ptr == nil {

		fmt.Println("true") // true

	}

	if p.s == nil {

		fmt.Println("true") // true

	}

	if p.m == nil {

		fmt.Println("true") // true

	}

	// 使用slice和map时，一定要make！！！

	p.s = make([]int, 2)

	p.s[0] = 88

	fmt.Println(p.s) // [88 0]

	p.m = make(map[string]string, 2)

	p.m["key"] = "value"

	fmt.Println(p.m) // map[key:value]

}

package main

import (

	"encoding/json"

	"fmt"

)

type Person struct{

	Name string `json:"name"` // `json:"name"`就是结构体tag

	Age int // `json:"age"` ，没有写tag，序列化后则为大写字母，如果字段为小写，其他包又不可见

}

func main() {

	person := Person{"佩奇", 18}

	jsonStr, err := json.Marshal(person)

	if err != nil {

		fmt.Println(err)

	} else {

		fmt.Println(string(jsonStr)) // {"name":"佩奇","Age":18}

	}

}

type Student struct {

	A int

	B int

	C int

}

func main() {

	s := Student{1, 20, 300}

	fmt.Println(&s.A) // 0xc00000e3a0

	fmt.Println(&s.B) // 0xc00000e3a8

	fmt.Println(&s.C) // 0xc00000e3b0

}

type A struct {

	Name string

}

type B struct {

	Name string

}

type C A // 结构体进行type重新定义（相当于取别名）

func main() {

	var a A

	var b B

	a = A(b) // 可以强转，但有前提

	var c C

	c = C(a) // 可以强转

	fmt.Println(a, b, c)

}