Go语言学习笔记十七--Go语言面向对象struct的基本使用

一、定义struct并创建对象及所有的初始化对象的方式

package main

import "fmt"

// type 关键字表示定义一种类型
// struct 表示定义一个类 里面的字段占用一块连续的内存空间
type User struct {
    UserName string
    Age int
    Sex string
    //结构体里面的字段 大写表示公开，小写表示私有（包内可以访问，包外不能访问）
    salary int

}

func main() {
    //第一种初始化方式
    var user1 User
    user1.UserName = "xwxz"
    user1.Age = 18
    user1.Sex = "man"
    fmt.Println("user1:",user1)

    //第二种初始化方式 当然里面的属性可以部分赋值
    var user2 User = User{
        UserName : "xw",
        Age : 18,
        Sex : "man",
    }
    fmt.Println("user2:",user2)

    //第三种方式
    user3 := User{
        UserName : "xw",
    }
    fmt.Println("user3:",user3)

     //第四种使用方式赋值给结构体指针
     var user4 *User = &User{
         UserName : "指针",
         Age : 18,
         Sex : "man",
     }
    fmt.Println("user4:", *user4)

     //第五种，使用new关键字
    var user5 *User = new(User)
    user5.UserName = "使用new关键字创建的对象" //go语言做了语法简化
    (*user5).Age = 17 //其实应该是这种写法
    fmt.Println("user5:", *user5)
}

 

运行结果：

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

 

二、Go语言构造函数

go语言其实没有构造函数，够着函数都是自己写的函数

package main

import "fmt"

type Student struct {
    StuName string
    Age int
    Sex string

}
//在go语言里面没有构造函数和析构函数 这些函数都需要自己去实现
func NewStu(stuName string, age int, sex string) *Student {
    //第一种方式
    /*
    stu := &Student{
        StuName: stuName,
        Age: age,
        Sex: sex,
    }
    return stu
    */
     //第二种方式 使用new
    stu := new(Student)
    stu.StuName = stuName
    stu.Age = age
    stu.Sex = sex
    return stu
}
func main() {
    stu := NewStu("xxw",18,"men")
    fmt.Println(stu)
}

运行结果：

&{xxw 18 men}

 

三、go语言struct对象匿名字段

package main

import "fmt"

type Person struct {
    StuName string
    string //匿名字段，只有类型 没有名字的字段
    int    //默认使用类型名作为字段名
}

func main() {

    peo := new(Person)
    peo.StuName = "xxw"
    peo.string = "men"
    peo.int = 20
    fmt.Println(peo)

}

运行结果：

&{xxw men 20}

四、go语言对象（结构体）嵌套

package main

import "fmt"

type Worker struct {
    WorkerName string
    Age int
    Address *Address
}

type Address struct {
    CityName string
    CityNum int
}

type Boss struct {
    BossName string
    Age int
    Address //匿名字段
}

func main() {
    work1 := Worker{
        WorkerName: "xxw",
        Age: 20,
        Address: &Address{
            CityName: "北京",
            CityNum: 10001,
        },
    }
    fmt.Println(work1)

    //匿名字段使用方式一 直接访问匿名字段里面的属性
    boss1 := new(Boss)
    boss1.BossName = "xw"
    boss1.Age = 30
    boss1.Address = Address{
        CityName: "上海",
        CityNum: 200002,
    }
    fmt.Println("boss1 : ",boss1)


    //匿名字段使用方式二 直接访问匿名字段里面的属性
    boss := new(Boss)
    boss.BossName = "xw"
    boss.Age = 30
    boss.CityName = "beijing"
    boss.CityNum = 10011
    fmt.Println("boss : ",boss)
}

运行结果：

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

 五、tag与json序列化

package main

import (
    "encoding/json"
    "fmt"
)

type Vip struct {
    //通过``来写tag 这样子通过反射机制可以获取到写的tag 多个tag以逗号隔开
    UserName string `json:"user_name"`
    Age int            `json:"age"`
    Sex string
}

func main() {
    user := &Vip{
        UserName: "xw",
        Age: 18,
        Sex: "men",
    }
    //json对象序列化
    data,_ := json.Marshal(user)
    fmt.Println(data)
    fmt.Println(string(data))
}

运行结果

[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"}