结构体
1. 自定义类型
Go语言中可以使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义,也可以通过struct定义。例如:
//将MyInt定义为int类型,通过Type关键字的定义,MyInt就是一种新的类型,它具有int的特性。
type MyInt int
自定义类型与类型别名的区别
package main
import "fmt"
// 类型定义
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
2. 结构体内嵌
Go语言的结构体内嵌是一种组合特性,使用结构体内嵌可构建一种面向对象编程思想中的继承关系
。 结构体实例化后,可直接访问内嵌结构体的所有成员变量和方法。
// 废话,都嵌进来,肯定能访问,但是如果A继承B,A可以完全使用B的成员,那么B能使用A的吗?能的话,能使用多少?使用到什么程度?---- 用不了
例:
// 内嵌及初始化
package main
import "fmt"
type Book struct {
title string
author string
num int
id int
}
type BookBorrow struct {
Book
borrowTime string
}
type BookNotBorrow struct {
Book
readTime string
}
func main() {
// 键值初试化
// 使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
bookBorrow := &BookBorrow{
Book: Book{title: "golang", author: "Tom",
num: 20, id: 123456,
},
borrowTime: "2022.01.02",
}
// 列表初始化
bookNotBorrow := &BookNotBorrow{
Book: Book{"python",
"Jan",
10,
654321,
},
readTime: "2022.01.03",
}
fmt.Println(bookBorrow)
fmt.Println(bookNotBorrow)
}
3. 匿名结构体
例:
package main
import (
"fmt"
)
func main() {
var user struct{Name string; Age int}
user.Name = "pprof.cn"
user.Age = 18
fmt.Printf("%#v\n", user)
}
3.1 取结构体的地址实例化
使用&
对结构体进行取地址
操作相当于对该结构体类型进行了一次new实例化
操作。
package main
import "fmt"
type inter int
type Person struct {
name string
city string
age inter
}
func main() {
var n = &Person{}
fmt.Printf("%T\n", n)
// 输出
*main.Person
p3.name = "博客"
p3.age = 30
p3.city = "成都" // 等价于(*p3).city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"博客", city:"成都", age:30}
// 输出
p3=&main.Person{name:"博客", city:"成都", age:30}
}
3.2 使用键值对初始化
使用键值对
对结构体进行初始化时,键
对应结构体的字段
,值
对应该字段的初始值
。
package main
import "fmt"
type inter int
type person struct {
name string
city string
age inter
}
func main() {
p5 := person{
name: "pprof.cn",
city: "北京",
age: 18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"pprof.cn", city:"北京", age:18}
// 也可以
p6 := &person{
name: "pprof.cn",
city: "北京",
age: 18,
}
fmt.Printf("p6=%#v\n", (*p6))
}
当某些字段没有初始值的时候,该字段可以不写。此时,没有指定初始值的字段的值就是该字段类型的零值。
p7 := &person{
city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}
面试题
package main
import "fmt"
type student struct {
name string
age int
}
func main() {
m := make(map[string]*student)
stus := []student{
{name: "pprof.cn", age: 18},
{name: "测试", age: 23},
{name: "博客", age: 28},
}
// 主要问题在这
//for _, stu := range stus {
// m[stu.name] = &stu
// for range 是创建了每个元素的副本然后映射该副本,并不是返回对元素的引用,而且使用的一直是同一个遍历指针,
// 这在循环读取中是没有问题的。但如果循环建立哈希表,使用遍历的指针作为每个键的映射,
// 那么循环结束后会指向最后一个元素,造成所有的值都是同一个。
for i, stu := range stus {
m[stu.name] = &stus[i]
}
for k, v := range m {
fmt.Println(k, "=>", v.name)
}
}
3.3 构造函数
package main
import "fmt"
type person struct {
name string
city string
age int8
}
func newPerson(name string, city string, age int8) *person {
return &person{
name: name,
city: city,
age: age,
}
}
func main() {
p9 := newPerson("pprof.cn", "测试", 90)
fmt.Printf("%#v\n", p9)
}
3.4 方法和接收者(你试一下,以接收者的思想看待方法)
方法:
方法就是作用在接收器(receiver)上的一个函数;
接收器:
某个类型的变量;
Go语言中的方法(Method)是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者(方法作用于特定类型
)(Receiver)。接收者的概念就类似于其他语言中的this或者 self。
方法的定义格式如下:
// (接收者变量 接收者类型) --> 绑定关系
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
其中,
1.接收者变量:接收者中的参数变量名在命名时,官方建议使用接收者类型名的第一个小写字母,而不是self、this之类的命名。例如,Person类型的接收者变量应该命名为 p,Connector类型的接收者变量应该命名为c等。
2.接收者类型:接收者类型和参数类似,可以是指针类型和非指针类型。
3.方法名、参数列表、返回参数:具体格式与函数定义相同。
func (p Person) Dream() {
fmt.Printf("%s的梦想是学好Go语言!\n", p.name)
}
3.5 指针类型的接收者
package main
import "fmt"
//Person 结构体
type Person struct {
name string
age int8
}
//NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
return &Person{
name: name,
age: age,
}
}
func (p *Person) SetAge(newAge int8) {
p.age = newAge
}
func main() {
p1 := NewPerson("测试", 25)
fmt.Printf("%T\n", p1)
p1.SetAge(30)
fmt.Println(p1.age)
}
// 输出
*main.Person
30
3.6 结构体的继承
package main
import "fmt"
type Animal struct {
name string
}
func (a *Animal) move(){
fmt.Printf("%s会动\n" , a.name)
}
// Gog
type Dog struct {
Feet byte
*Animal // 通过嵌套匿名结构体(光把类型带进来了,没写变量)实现继承
}
func (d *Dog) wang(){
fmt.Printf("%s会汪汪汪~\n", d.name)
}
func main(){
// 结构体实例化
d1 := &Dog{
Feet: 4,
// Dog结构体继承了Animal结构体的方法
Animal : &Animal{name: "乐乐",},
}
d1.wang()
d1.move()
}
3.7 结构体与JSON序列化
package main
import (
"encoding/json"
"fmt"
)
//Student 学生
type Student struct {
ID int
Gender string
Name string
}
//Class 班级
type Class struct {
Title string
Students []*Student
}
func main() {
// 实例化
c := &Class{
Title: "101",
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)
//JSON反序列化:JSON格式的字符串-->结构体
str := `{"Title":"101","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"}]}`
c1 := &Class{}
err = json.Unmarshal([]byte(str), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n", c1)
}
方法
定义上文已提及,不再赘述
func (recevier type) methodName(参数列表)(返回值列表){}
参数和返回值可以省略
注意:
注意,当方法的接受器不是一个指针时,方法操作对应接受器的值的副本,意思就是即使你使用了指针调用函数,但是函数的接受者是值类型,你还是传的值,而非指针,所以函数内部操作还是对副本的操作,而不是指针操作。可笑的是,当接受者是指针时,即使用值类型调用那么函数内部也是对指针的操作(双标吗?)。
不双标,方法有自主权,如果自己都没有选择自己成为什么样的人的权利,那也太可笑了。
1. receiver T 和 *T
的差别。
package main
import "fmt"
type Data struct {
x int
}
func (self Data) ValueTest(){ // 函数形式:func ValueTest(self Data);
fmt.Printf("Value is %p\n", &self)
}
func (self *Data) PointerTest() { // 函数形式:func PointerTest(self *Data);
fmt.Printf("Pointer: %p\n", self)
}
func main(){
d := Data{}
p := &d
fmt.Printf("Data: %p, type: %T\n", p, p)
d.ValueTest() // ValueTest(d)
d.PointerTest() // PointerTest(&d) 指针
p.ValueTest() // ValueTest(*p)
p.PointerTest() // PointerTest(p) 指针
}
// 输出
Data: 0xc00001a0a8, type: *main.Data
Value is 0xc00001a0c8
Pointer: 0xc00001a0a8
Value is 0xc00001a0e0
Pointer: 0xc00001a0a8
饶了我半天。。。。。指针传递本来就传的同一个地址啊;改变值就要改变变量,不同变量的地址肯定不一样
匿名字段(很萌、很猛)
结果:
// 这块地址装这么多东西
Manager: 0xc00010e4b0, &{{1 Tom} Administrator}
User: 0xc00010e4b0, &{1 Tom}
方法总结:
func (p *Person) insert (a int) int{}
t() // PointerTest§ 指针
}
// 输出
Data: 0xc00001a0a8, type: *main.Data
Value is 0xc00001a0c8
Pointer: 0xc00001a0a8
Value is 0xc00001a0e0
Pointer: 0xc00001a0a8
饶了我半天。。。。。指针传递本来就传的同一个地址啊;改变值就要改变变量,不同变量的地址肯定不一样
# 匿名字段(很萌、很猛)
[外链图片转存中...(img-misPugRK-1689745885036)]
结果:
```go
// 这块地址装这么多东西
Manager: 0xc00010e4b0, &{{1 Tom} Administrator}
User: 0xc00010e4b0, &{1 Tom}
方法总结:
func (p *Person) insert (a int) int{}