1 package main
 2 
 3 import "fmt"
 4 
 5 // type 关键字表示定义一种类型
 6 // struct 表示定义一个类 里面的字段占用一块连续的内存空间
 7 type User struct {
 8     UserName string
 9     Age int
10     Sex string
11     //结构体里面的字段 大写表示公开，小写表示私有（包内可以访问，包外不能访问）
12     salary int
13 
14 }
15 
16 func main() {
17     //第一种初始化方式
18     var user1 User
19     user1.UserName = "xwxz"
20     user1.Age = 18
21     user1.Sex = "man"
22     fmt.Println("user1:",user1)
23 
24     //第二种初始化方式 当然里面的属性可以部分赋值
25     var user2 User = User{
26         UserName : "xw",
27         Age : 18,
28         Sex : "man",
29     }
30     fmt.Println("user2:",user2)
31 
32     //第三种方式
33     user3 := User{
34         UserName : "xw",
35     }
36     fmt.Println("user3:",user3)
37 
38      //第四种使用方式赋值给结构体指针
39      var user4 *User = &User{
40          UserName : "指针",
41          Age : 18,
42          Sex : "man",
43      }
44     fmt.Println("user4:", *user4)
45 
46      //第五种，使用new关键字
47     var user5 *User = new(User)
48     user5.UserName = "使用new关键字创建的对象" //go语言做了语法简化
49     (*user5).Age = 17 //其实应该是这种写法
50     fmt.Println("user5:", *user5)
51 }

user1: {xwxz 18 man}
user2: {xw 18 man}
user3: {xw 0 }
user4: {指针 18 man}
user5: {使用new关键字创建的对象 17 }

 1 package main
 2 
 3 import "fmt"
 4 
 5 type Student struct {
 6     StuName string
 7     Age int
 8     Sex string
 9 
10 }
11 //在go语言里面没有构造函数和析构函数 这些函数都需要自己去实现
12 func NewStu(stuName string, age int, sex string) *Student {
13     //第一种方式
14     /*
15     stu := &Student{
16         StuName: stuName,
17         Age: age,
18         Sex: sex,
19     }
20     return stu
21     */
22      //第二种方式 使用new
23     stu := new(Student)
24     stu.StuName = stuName
25     stu.Age = age
26     stu.Sex = sex
27     return stu
28 }
29 func main() {
30     stu := NewStu("xxw",18,"men")
31     fmt.Println(stu)
32 }

&{xxw 18 men}

 1 package main
 2 
 3 import "fmt"
 4 
 5 type Person struct {
 6     StuName string
 7     string //匿名字段，只有类型 没有名字的字段
 8     int    //默认使用类型名作为字段名
 9 }
10 
11 func main() {
12 
13     peo := new(Person)
14     peo.StuName = "xxw"
15     peo.string = "men"
16     peo.int = 20
17     fmt.Println(peo)
18 
19 }

&{xxw men 20}

 1 package main
 2 
 3 import "fmt"
 4 
 5 type Worker struct {
 6     WorkerName string
 7     Age int
 8     Address *Address
 9 }
10 
11 type Address struct {
12     CityName string
13     CityNum int
14 }
15 
16 type Boss struct {
17     BossName string
18     Age int
19     Address //匿名字段
20 }
21 
22 func main() {
23     work1 := Worker{
24         WorkerName: "xxw",
25         Age: 20,
26         Address: &Address{
27             CityName: "北京",
28             CityNum: 10001,
29         },
30     }
31     fmt.Println(work1)
32 
33     //匿名字段使用方式一 直接访问匿名字段里面的属性
34     boss1 := new(Boss)
35     boss1.BossName = "xw"
36     boss1.Age = 30
37     boss1.Address = Address{
38         CityName: "上海",
39         CityNum: 200002,
40     }
41     fmt.Println("boss1 : ",boss1)
42 
43 
44     //匿名字段使用方式二 直接访问匿名字段里面的属性
45     boss := new(Boss)
46     boss.BossName = "xw"
47     boss.Age = 30
48     boss.CityName = "beijing"
49     boss.CityNum = 10011
50     fmt.Println("boss : ",boss)
51 }

{xxw 20 0xc00000c080}
boss1 :  &{xw 30 {上海 200002}}
boss :  &{xw 30 {beijing 10011}}

 1 package main
 2 
 3 import (
 4     "encoding/json"
 5     "fmt"
 6 )
 7 
 8 type Vip struct {
 9     //通过``来写tag 这样子通过反射机制可以获取到写的tag 多个tag以逗号隔开
10     UserName string `json:"user_name"`
11     Age int            `json:"age"`
12     Sex string
13 }
14 
15 func main() {
16     user := &Vip{
17         UserName: "xw",
18         Age: 18,
19         Sex: "men",
20     }
21     //json对象序列化
22     data,_ := json.Marshal(user)
23     fmt.Println(data)
24     fmt.Println(string(data))
25 }

[123 34 117 115 101 114 95 110 97 109 101 34 58 34 120 119 34 44 34 97 103 101 34 58 49 56 44 34 83 101 120 34 58 34 109 101 110 34 125]
{"user_name":"xw","age":18,"Sex":"men"}