10- Go语言基础之结构体

Go 语言中没有”类”的概念, 也不支持”类”的继承等面向对象的概念, Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性.

类型别名和自定义类型

自定义类型

在Go 语言中有一些基本的数据类型, 如string ,整型 ,浮点型 等数据类型, Go语言中可以使用type关键字来第定义自定义类型.

自义定类型是定义了一个全新的类型. 我们可以基于内置的基本类型定义, 也可以通过struct 定义.

type MyInt int

通过 type 关键字定义, MyInt 就是一种新的类型. 它具有int的特性

类型别名

类型别名是Go1.9 版本添加的新功能.

类型别名规定: TypeAlia 只是Type的别名, 本质上TypeAlias 与Type 是同一个类型.

type TypeAlias = Type

我们之前见过rune 和byte 就是类型别名.

type byte = unit8
type rune = int32

类型定义和类型别名的区别

类型别名与类型定义表面上看只有一个等号的差异.

// 类型定义
type NewInt int
// 类型别名
type MyInt = int
func main() {
    var a NewInt
    var b MyInt
    fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int
}

结果显示a的类型是 main.NewInt, 表示main包下定义的NewInt 类型. b 的类型是int. MyInt 类型只会在代码中存在, 编译完成时并不会有MyInt 类型.

结构体

Go 语言中的基础数据类型可以表示一些事物的基本属性. 但是当我们想表达一个事物的全部或者部分属性时, 这时候再用单一的基本数据类型明显就无法满足需求, Go 语言提供了一种自定义数据类型, 可以封装多个基本数据类型 , 这种数据类型叫结构体, 英文名struct

Go 中语言通过struct 来实现面向对象

结构体的定义

使用type 和 struct 关键字来定义结构体

type 类型名 struct {
    字段名  类型
    字段名  类型
}

其中:

类型名: 结构体的名称, 在一个包内不能重复.
字段名: 标识结构体内字段的名字, 在结构体中必须唯一
字段类型, 结构体内字段的具体类型

举例:

type person struct {
    name string
    age int8 
    city string
}

同样类型的字段可以写在一行

type person struct {
    name, city  string
    age  int8
}

这样我们就拥有了一个person 的自定义类型, 它有name, city age 三个字段,

语言内置的基础数据类型是用来描述一个值的, 而结构体是用来描述一组值的, 本质上是一种聚合性的数据类型.

结构体实例化

只有结构体实例化时, 才会真正的分配内存 也就是必须实例化后才能够使用结构体的字段.

结构体本身也是一种类型, 我们可以像声明内置类型一样使用var 关键字声明结构体

var 结构体实例 结构体类型

基本实例化

type person struct {
    name string
    age int8
    city string
}
func main() {
    var p1 person
    p1.name = "张三"
    p1.city = "杭州"
    p1.age = 18
    fmt.Printf("p1=%v\n", p1)
    fmt.Printf("p1=%#v\n", p1)
}

我们通过. 来访问结构体字段(成员变量), 例如p1.name, p1.age 等.

匿名结构体

在定义一些临时数据结构的场景下我们可以使用匿名结构体

func main() {
    var user struct{Name string; Age int}
    user.Name = "张大仙"
    user.Age = 29
    fmt.Printf("%#v\n", user)
}

指针类型结构体

我们可以通估new 关键字对结构体进行实例化, 得到的是结构体地址.

var p2 = new(person)
fmt.Printf("%T\n", p2)    //*main.person
fmt.Printf("p2=%#v\n", p2)  //p2=&main.person{name:"", city:"", age:0}

从打印的结果中我们可以看出p2 是一个结构体指针

需要注意的是在Go语言中支持对结构体指针使用. 来访问结构体成员

var p2 = new(person)
p2.name = "张大仙"
p2.age = 29
p2.city = "北京"
fmt.Printf("p2=%#v\n", p2)

结构体的地址实例化

使用& 对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作

p2 = &person{}
fmt.Printf("%T\n", p3)     //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "张大仙"
p3.age = 29
p3.city = "上海"
fmt.Printf("p3=%#v\n", p3)

p3.name = "张大仙" 其实在底层是(*p3).name = "张大仙", 这是 Go 语言帮我们实现的语法糖

结构体初始化

没有初始化的结构体, 其成员变量都是对应其类型的零值

type person struct {
    name string
    age int
    city string
}
func main() {
    var p4 person
    fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", age:0, city:""}
}

使用键值对初始化

使用键值对对结构体进行初始化时, 键对应结构体的字段, 值对应字段的初始值

p5 := person{
    name:"张大仙",
    age:29,
    city: "成都"
}
fmt.Printf("p5=%#v\n", p5)  // p5=main.person{name:"张大仙", age:29, city:"成都"}

也可以对结构体指针进行键值对初始化,

p6 := &person{
    name:"张大仙",
    age:29,
    city: "成都"
}
fmt.Printf("p5=%#v\n", p6)  // p5=&main.person{name:"张大仙", age:29, city:"成都"}

当某些字段没有初始值的时候, 该字段可以不写, 此时没有指定初始值的字段就是该字段类型的零值.

p7:= &person{
    name: "王八蛋"
}
fmt.Printf("p5=%#v\n", p7) // p7=&main.person{name:"王八蛋", age:0, city:""}

使用值列表初始化

初始化结构体时, 可以简写

p8 := &person{
    "王三胖",
    19,
    "火星",
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"王三胖", age:19, city:"火星"}

注意事项:

必须初始化结构体的所有字段
初始值的顺序必须与字段在结构体中的声明顺序一致
该方式不能喝键值初始方式混用

结构体内存布局

结构体占用一块连续的内存.

type test struct {
    a int8
    b int8
    c int8
    d int8
}
n := &test(1,3,4,5)
fmt.Printf("n.a %p\n", &n.a)
fmt.Printf("n.b %p\n", &n.b)
fmt.Printf("n.c %p\n", &n.c)
fmt.Printf("n.d %p\n", &n.d)

输出

n.a 0xc00000a0b0
n.b 0xc00000a0b1
n.c 0xc00000a0b2
n.d 0xc00000a0b3

【进阶知识点】关于Go语言中的内存对齐推荐阅读:在 Go 中恰到好处的内存对齐

空结构体

空结构体是不占用空间的

var v struct{}
fmt.Println(unsafe.Sizeof(v))  // 0

面试题

type student struct {
    name string
    age  int
}
func main() {
    m := make(map[string]*student)
    stus := []student{
        {name: "小王子", age: 18},
        {name: "娜扎", age: 23},
        {name: "大王八", age: 9000},
    }
    for _, stu := range stus {
        m[stu.name] = &stu
    }
    for k, v := range m {
        fmt.Println(k, "=>", v.name)
    }
}

构造函数

Go 语言的结构体没有构造函数, 我们可自己实现.

因为struct 是值类型, 如果结构体比较复杂的话, 值拷贝性能开销会比较大, 所以构造函数返回的是结构体的指针类型

func newPerson(name, city string, age int8) *person {
    return &person{
        name:name,
        age: age,
        city: city,
    }
}

调用构造函数

p9 := newPerson("张三", "迪拜", 99)
fmt.Printf("%#v\n", p9) //&main.person{name:"张三", age:99, city:"迪拜"}

方法和接收者

Go 语言中的方法(Method) 是一种作用域特定类型变量的函数. 这种特定类型变量叫做接收者(receiver) . 接收者的概念就类似于其他语言中的this 或者 self

方法的定义格式.

func (接收者变量  接收者类型) 方法名 (参数列表)(返回参数) {
    函数体
}

其中:

接收者变量: 接收者中的参数变量名在命名时, 官方建议使用接收者类型名称首字母的小写, 而不是self , this 之类的命名.
接收者类型: 接收者类型和参数类型, 可以是指针类型和非指针类型.
方法名, 参数列表, 返回参数: 具体格式与函数定义相同.

举例

// Person 结构体
type Person struct {
    name string
    age int8
}
//  newPerson 构造函数
func newPerson(name string, age int8) *Person {
    return &Person{
        name: name,
        age: age,
    }
}
// Eat Person的吃方法
func (p Person) Eat() {
    fmt.Printf("%s 的梦想是吃遍全世界. \n", p.name)
}
func main() {
    p1 := newPerson("大聪明", 22)
    p1.Eat()
}

方法与函数的区别是, 函数不属于任何类型. 方法属于特定的类型.

指针接收者

指针类型的接收者由一个结构体的指针组成. 由于指针的特性, 调用方法是修改接收者指针的任意成员变量, 在方法结束后, 修改都是有效的. 这种方式就十分接近于其他语言中this , self

例子:

func (p *Person)SetAge(newAge, int8) {
    p.age = newAge
}

调用该方法

func main() {
    p1 := NewPerson("大聪明", 22)
    fmt.Println(p1.age) // 22
    p1.SetAge(30)
    fmt.Println(p1.age) // 30
}

值类型的接收者

当方法作用于值类型的接收者时, Go 语言会在代码运行时将接收者的值复制一份. 在值类型接收者的方法中可以焯去接收者的成员值. 但修改操作只是针对副本,. 无法修改接收者变量本身.

/ SetAge2 设置p的年龄
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
    p.age = newAge
}
func main() {
    p1 := NewPerson("大聪明", 22)
    p1.Dream()
    fmt.Println(p1.age) // 22
    p1.SetAge2(30) // (*p1).SetAge2(30)
    fmt.Println(p1.age) // 22
}

指针类型接收者的使用

需要修改接收者中的值
接收者时拷贝代价比较大的对象
保证一致性, 如果某个方法使用了指针接收者, 那么其他方法也应该使用指针接收者.

任意类型添加方法

在Go 语言中, 接收者的类型可以是任意类型, 不仅仅是结构体. 可以是Go 语言中的内置类型

// 将 int 自定义为 MyInt 类型
type MyInt int
// 给 MyInt 类型添加一个 SayHello 方法
func (m MyInt) SayHello() {
    fmt.Println("hello, 大傻子")
}
func main() {
    var m1 MyInt
    m1.SayHello() // hello, 大傻子
    m1 = 100
       fmt.Printf("%#v  %T\n", m1, m1) // 100 main.MyInt
}

注意事项: 非本地类型不能定义方法, 也就是说我们不能给别的包的类型定义方法.

结构体你名字段

结构体允许其成员字段在声明时没有字段名, 而只有类型. 这种没有名字的字段就称之为匿名字段.

//Person 结构体Person类型
type Person struct {
    string
    int
}
func main() {
    p1 := Person{
        "小王子",
        18,
    }
    fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}
    fmt.Println(p1.string, p1.int) //北京 18
}

注意这里匿名字段的说法并不代表没有字段名, 而是会采用类型名作为字段名, 结构体要求字段名必须唯一, 因此一个结构体中同类型的宁明字段只有一个.

嵌套结构体

一个结构体中可以嵌套包含另一个结构体或者结构体指针.

type Address struct {
    Province string
    City     string
}
type User struct {
    Name string
    age int
    Address Address
}
func main() {
    user1 := User{
        Name: "卧龙",
        age: 29,
        Address: Address{
            Province: "西虹",
            City: "西虹市",
        }
    }
    fmt.Printf("user1=%#v\n", user1) //user1=main.User{Name:"卧龙", age:29, Address:main.Address{Province:"西虹", City:"西虹市"}}
}

嵌套匿名字段

上面User 结构体中嵌套的Address 结构体也可以采用匿名字段方式.

type Address struct {
    Province string
    City     string
}
type User struct {
    Name string
    age int
    Address
}
func main() {
    var user2 User
    user2.Name = "凤雏"
    user2.age = 30
    user2.Address.Province = "西虹"  // 匿名字段的类型可以作为字段名
    user2.City = "西虹市"  // 匿名字段可以省略
    fmt.Printf("user2=%#v\n", user2)  //user2=main.User{Name:"凤雏", age:30, Address:main.Address{Province:"西虹", City:"西虹市"}}
}

当访问结构体成员时, 会先在结构体中查找改字段, 找不到再去嵌套的匿名字段中查找.

字段冲突

当嵌套匿名结构体中有相同的字段名, 则不可省略匿名字段. 否则会引发ambiguous selector 错误

type Address struct {
    Province string
    City     string
}
type School struct {
    City string
}
type User struct {
    Name string
    age int
    Address
    School
}
func main() {
    user3 := User{
            Name: "卧龙凤雏",
            age: 100,
            Address: Address{
                Province: "s",
                City: "北京",
            },
            School: School{
                City: "上海",
            },
        }
        fmt.Printf("user2=%#v\n", user3)
        fmt.Println(user3.City)
}

结构体的”继承”

Go 语言中使用结构体也可以实现其他变成语言中面向对象的继承.

//  Animal 动物
type Animal struct {
    name string
}
func (a *Animal) move() {
    fmt.Printf("%s会动 \n", a.name)
}
// Dog 狗东西
type  Dog struct {
    feet int8
    *Animal   //  通过匿名结构体进行继承
}
func (d *Dog)wang(){
    fmt.Printf("%s 会汪汪汪", d.name)
}
func main() {
    var d1 = &Dog{
        feet: 4,
        Animal: &Animal{   // 注意嵌套的是结构体指针
            name: "狗东西",
        },
    }
    d1.move()
    d1.wang()
}

结构体字段的可见性

结构体字啊吨大写开头表示可公开访问, 小写表示私有.

结构体与Json 序列化

JSOn 是一种轻量级的数据交换格式. 已与人阅读与编写.

type Student struct {
    ID int
    Gender string
    Name string
}
//  Class
type Class struct {
    Title string
    Students []*Student
}
func main() {
    c := &Class{
        Title: "一年级一班",
        Students: make([]*Student, 0, 200),
    }
    for i := 0; i < 10; i++ {
        stu := &Student{
            Name: fmt.Sprintf("stu%02d", i),
            Gender: "男",
            ID: i,
        }
        c.Students = append(c.Students, stu)
    }
    // JSON 序列化: 结构体 --> JSON 格式的字符串
    data, err := json.Marshal(c)
    if err != nil {
        fmt.Println("json marshal failed")
        return
    }
    fmt.Printf("json: %s \n", data)
    c1 := &Class{}
    str := `{"Title":"一年级一班","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]} `
    err = json.Unmarshal([]byte(str), c1)
    if err != nil {
        return
    }
    fmt.Printf("%#v\n", c1)
}

结构体标签

Tag 是结构体的源信息, 可以在运行的时候可以通过反射机制读取出来, Tag za在结构体字段的后方定义, 由一堆反引号包裹起来, 具体格式如下:

`key1: "value1" key2:"value2"`

结构体tag 由一个或多个键值对组成,
键与值之间用冒号分隔
值用双引号括起来
同一个结构体字段可以设置多个键值对tag
不同的键值对之间使用空格分隔,

注意事项:

为结构体编写Tag 时西部严格遵守键值对的规则.
结构体标签的解析代码的容错能力很差,.
写错不会提示任何错误. 通过反射无法正确取值.

//Student 学生
type Student struct {
    ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key
    Gender string //json序列化是默认使用字段名作为key
    name   string //私有不能被json包访问
}
func main() {
    s1 := Student{
        ID:     1,
        Gender: "男",
        name:   "卧龙凤雏",
    }
    data, err := json.Marshal(s1)
    if err != nil {
        fmt.Println("json marshal failed!")
        return
    }
    fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}

结构体和方法补充知识点

因为 slice 和 map 这两种数据类型都包含了指向底层数据的指针, 因此我们再需要复制他们是要特别注意. 我们来看下面的例子

type Person struct {
    name string
    age int8 
    dreams []string
}
func(p *Person) SetDreams(dreams []string) {
    p.dreams = dreams
}
func main() {
    p1 := Person{name:"卧龙", age: 29}
    data := []string{"吃饭", "凤雏", "大聪明"}
    p1.SetDreams(data)
    data[1] = "不睡觉"
    fmt.Println(p1.dreams)  // [吃饭 不睡觉 大聪明]
}

正确的做饭是在方法中使用传入的slice的拷贝进行结构体赋值

func(p *Person) SetDreams(dreams []string) {
    p.dreams = make([]string, len(dreams))
    copy(p.dreams, dreams)
}

同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题。

练习题

使用“面向对象”的思维方式编写一个学生信息管理系统。
1. 学生有id、姓名、年龄、分数等信息
2. 程序提供展示学生列表、添加学生、编辑学生信息、删除学生等功能