(转)Go-18 Golang结构体struct详解

原文:https://www.cnblogs.com/ludundun/p/16998752.html

package main import "fmt" // Golang中的结构体详解 type newInt int // 自定义类型 type myInt = int // 类型别名 type zsInt int type person struct { name string city string age int8 } type PerSon struct { name string age int } // 匿名字段结构体 type PersonMan struct { string int } // 定义Address地址结构体 type Address struct { Province string City string } // 定义User用户结构体 type User struct { Name string Gender string Address Address // 在这里就是结构体中嵌套了另一个结构体 } // UserT 用户结构体中嵌套匿名结构体 type UserT struct { Name string Gender string Address // 匿名结构体 } // Animal 动物 type Animal struct { name string } // Dog 狗 type Dog struct { Age int8 *Animal // 通过嵌套匿名结构体实现继承 } func (a *Animal) run() { fmt.Printf("%s 会运动! \n", a.name) } func (d *Dog) wang() { fmt.Printf("%s 会汪汪汪~ \n", d.name) } // 值类型接收者 func (p PerSon) printInfo() { fmt.Printf("姓名:%v 年龄:%v \n", p.name, p.age) // 姓名:小王子 年龄:25 } // 指针类型接收者 func (p *PerSon) setInfo(name string, age int) { p.name = name p.age = age } func (m zsInt) SayHello() { fmt.Println("Hello, 我是一个int...") } func main() { /* 1.关于Golang结构体 Golang中没有"类"的概念,Golang中的结构体和其他语言中的类有点相似。和其他面向对象语言中的类相比, Golang中的结构体具有更高的扩展性和灵活性。 Golang结构体因何而出: Golang中的基础数据类型可以表示一些事物的基本属性,但是当我们想表达一个事务的全部或部分属性时,这时候再用单一的基本数据类型就无法满足 要求了,Golang中提供了一种自定义数据类型,可以封装多个基本数据类型,这种数据类型叫结构体,英文名struct。也就是我们可以通过struct 来定义我们自己的类型了。 2.Golang type 关键字自定义类型和类型别名 Golang中通过type关键字定义一个结构体。 2.1 type自定义类型 在Go语言中有一些基本的数据类型,如string、整型、浮点型、布尔等数据类型,Go语言中可以使用type关键字来定义自定义类型。 type myint int 这个表示将myint定义为int类型,通过type关键字的定义,myint就是一种新的类型,它具有int的特性。 2.2 定义类型别名 Golang1.9版本以后添加的新功能。类型别名规定:TypeAlias只是Type的别名,本质上TypeAlias与Type是同一个类型。就像 一个小孩小时候有大名、小明、英文名,但这些名字都指的是他本人。 type TypeAlias = Type ,我们之前见过的rune和byte就是类型别名,他们的底层定义如下: type byte = uint8 type rune = int32 2.3 自定义类型和类型别名的区别 类型别名与自定义类型表面上看只有一个等号的差异,我们通过下面的这段代码来理解他们之间的区别。 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 } 结果显示a的类型是main.newInt,表示main包下定义的newInt类型。b的类型是int类型。 3.结构体定义初始化的几种方法 3.1 结构体的定义 使用type和struct关键字来定义结构体,具体代码格式如下: type 类型名 struct { 字段名 字段类型 字段名 字段类型 字段名 字段类型 ..... ...... } 其中: 1.类型名:表示自定义结构体的名称,在同一个包内不能重复。 2.字段名:表示结构体字段名。结构体中的字段名必须唯一。 3.字段类型:表示结构体字段的具体类型。 举例,我们定义一个person人类的结构体,代码如下: type person struct { name string city string age int8 } 同样类型的字段也可以写在一行: type person struct { name, city string age int8 } 注意:结构体首字母可以大写,也可以小写,大写表示这个结构体是公有的,在其他的包里面可以使用。小写表示这个结构体是私有的,只有这个包里面才能使用。 3.2 结构体实例化(第一种方法) 只有当结构体实例化时,才会真正的分配内存。也就是必须实例化后才能使用结构体的字段。结构体本身也是一种类型,我们可以 像声明内置类型一样使用var关键字声明结构体类型。 var 结构体实例 结构体类型,例如借用上面的结构体进行声明:var p1 person package main import "fmt" type person struct { name string city string age int8 } func main() { var p1 person p1.name = "张三" p1.city = "北京" p1.age = 18 fmt.Printf("p1=%v \n", p1) // p1={张三 北京 18} fmt.Printf("p1=%#v \n", p1) // p1=main.person{name:"张三",city:"北京",age:18} } 3.3 结构体实例化(第二种方法) 我们可以使用new关键字对结构体进行实例化,得到的是结构体的地址。格式如下: package main import "fmt" type person struct { name string city string age int } func main() { var p2 = new(person) p2.name = "张三" p2.city = "北京" p2.age = 20 fmt.Printf("%T \n", p2) // *main.person fmt.Printf("p2=%#v \n", p2) //p2=&main.person{name:"张三",city:"北京",age:20} } 从打印的结果中我们可以看出p2是一个结构体指针。注意:在Golang中支持对结构体指针直接使用,来访问结构体的成员。 p2.name="张三" 其实在底层是(*p2).name="张三" 3.4 结构体实例化(第三种方法) 使用&对结构体进行取地址操作。 package main import "fmt" type person struct { name string city string age int } func main() { p3 := &person{} fmt.Printf("%T \n", p3) // *main.person fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"",city:"",age:0} p3.name = "张三" p3.city = "北京" p3.age = 20 // (*p3).age = 50 // 这样也是可以的 fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"张三",city:"北京",age:20} } 3.5 结构体实例化(第四种方法)键值对初始化 package main import "fmt" type person struct { name string city string age int } func main() { p4 := person{ name:"张三", city:"北京", age:18, // 要注意,最后一个属性的逗号要加上不能丢。 } fmt.Printf("p4=%#v \n", p4) // p4=&main.person{name:"张三",city:"北京",age:18} } 3.6 结构体实例化(第五种方法)结构体指针进行键值对初始化 package main import "fmt" type person struct { name string city string age int } func main() { p5 := &person{ name: "张三", city: "北京", age: 28, } fmt.Printf("p5=%#v \n", p5) // p5=&main.person{name:"张三",city:"北京",age:28} } 当某些字段没有初始值的时候,这个字段可以不写。此时,没有指定初始值的字段采用类型的零值。 package main import "fmt" type person struct { name string city string age int } func main() { p6 := &person{ city: "北京", } fmt.Printf("p6=%#v \n", p6) // p6=&main.person{name:"",city:"北京",age:0} } 3.7 结构体实例化(第六种方法)使用值的列表初始化 package main import "fmt" type person struct { name string city string age int } func main() { p7 := &person{ "zhangsan", "北京", 28, } fmt.Printf("p7=%#v \n", p7) // p7=&main.person{name:"zhangsan",city:"北京",age:28} } !!! 使用这种格式初始化时,需要注意: 1. 必须初始化结构体的所有字段。 2. 初始值的填充顺序必须和字段在结构体中的声明顺序一致。 3. 该方式不能和键值初始化方式混用。 4.结构体方法和接收者 在Go语言中,没有类的概念但是可以给类型(结构体,自定义类型)定义方法。所谓方法就是定义了接收者的函数。 接收者的概念就类似于Python语言中的self。 方法的定义格式如下: func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) { 函数体 } 其中: 1.接收者变量:接收者中的参数变量名在命名时,官方建议使用接收者类型名的第一个小写字母,而不是self、this之类的命名。 例如,Person类型的接收者变量应该命名为小写字母p,Connector类型的接收者变量应该命名为c等。总之接收者变量就是用小写字母。 2.接收者类型:接收者类型和参数类似,可以时指针类型和非指针类型。 3.方法名、参数列表、返回参数:具体格式与函数定义相同。 实例1: 给结构体Person定义一个方法打印Person的信息 package main import "fmt" type PerSon struct { name string age int8 } // 值类型接收者 func (p PerSon) printInfo() { fmt.Printf("姓名:%v 年龄:%v \n", p.name, p.age) } func main() { p1 := PerSon{ name: "小王子", age: 25, } p1.printInfo() } 4.1 值类型的接收者-------> 就是传入的参数类型前面没有*符号 当方法作用域值类型接收者时,Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值, 但修改操作只是针对副本,无法修改接收者变量本身。 4.2 指针类型的接收者--------> 就是传入的参数在类型前面会加上*符号 指针类型的接收者由一个结构体的指针组成,由于指针的特性,调用方法时修改接收者指针的任意成员变量,在方法结束后,修改都是有效的。 这种方式就十分接近于其他语言中面向对象中的this或者self。 下面写一下值类型和指针类型接收的示例: package main import "fmt" type Person struct { name string age int } // 下面定义一个printInfo方法和一个setInfo方法并绑定给结构体Person. // 值类型接收者 func (p Person) printInfo() { fmt.Printf("姓名:%v 年龄:%v \n", p.name, p.age) } // 指针类型接收者 func (p *Person) setInfo(name string, age int) { p.name = name p.age = age } func main() { p1 := Person{ name: "小王子", age: 25, } p1.printInfo() p1.setInfo("张三", 20) p1.printInfo() } // 上面的运行结果是: 值类型接收者和指针类型接收者运行结果: 姓名:小王子 年龄:25 姓名:张三 年龄:20 5.给任意类型添加方法 在Go语言中,接收者的类型可以是任何类型,不仅仅是结构体,任何类型都可以拥有方法。举个例子: 我们基于内置的int类型使用type关键字可以定义新的自定义类型,然后为我们的自定义类型添加方法。 package main import "fmt" type zsInt int func (m zsInt) SayHello() { fmt.Println("Hello, 我是一个int...") } func main() { var m1 zsInt m1.SayHello() // Hello, 我是一个int... m1 = 100 fmt.Printf("%#v %T \n", m1, m1) // 100 main.zsInt } 注意事项:非本地类型不能定义方法,也就是说我们不能给别的包的类型定义方法。 6.结构体的匿名字段 结构体允许其成员字段在声明时没有字段名而只有类型,这种没有名字的字段就称为匿名字段。 type PersonMan struct { string int } func main() { p1 := PersonMan{ "小王子", 18, } fmt.Printf("%#v \n", p1) // main.PersonMan{string:"北京", int:18} ------>>>> 匿名字段默认采用类型名作为字段名 fmt.Println(p1.string, p1.int) // 北京 18 } 匿名字段默认采用类型名作为字段名,结构体要求字段名称必须唯一,因此一个结构体中同种类型的匿名字段只能有一个。 简而言之就是每种类型只能出现一次,不能重复。 7.嵌套结构体 一个结构体中可以嵌套包含另一个结构体或结构体指针。 package main import "fmt" // 定义Address地址结构体 type Address struct { Province string City string } // 定义User用户结构体 type User struct { Name string Gender string Address Address // 在这里就是结构体中嵌套了另一个结构体 } func main() { user1 := User{ Name:"张三", Gender:"男", Address:Address{ Province:"广东", City:"深圳", }, } fmt.Printf("user1=%#v \n", user1) // 结果是:user1=main.User{Name:"张三",Gender:"男",Address:main.Address{Province:"广东",City:"深圳"}} } 8.嵌套匿名结构体 package main import "fmt" // Address 地址结构体 type Address struct{ Province string City string } // User 用户结构体 type User struct{ Name string Gender string Address // 匿名结构体 } func main() { var user2 UserT user2.Name = "张三" user2.Gender = "男" user2.Address.Province = "广东" // 通过匿名结构体.字段名访问 user2.City = "深圳" // 直接访问匿名结构体的字段名 fmt.Printf("user2=%#v \n", user2) // 结果是:user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}} } 【注意】:当访问结构体成员时会先在结构体中查找该字段,找不到再去匿名结构体中查找。这就是为什么可以用User2.City = "深圳" 不报错的原因。 9.关于嵌套结构体的字段名冲突 嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体字段。 package main import "fmt" // Address 地址结构体 type Address struct { Province string City string CreateTime string } // Email 邮箱结构体 type Email struct { Account string CreateTime string } // User用户结构体 type User struct { Name string Gender string Address Email } func main() { var user3 User user3.Name = "张三" user3.Gender = "男" //user3.CreateTime = "2020" // 这样是错误的,嵌套结构体内部有相同的字段,需要指名道姓用点的方式 user3.Address.CreateTime = "2020" // 指定Address结构体中的CreateTime user3.Email.CreateTime = "2021" // 指定Email结构体中的CreateTime } 10.结构体的继承 Go 语言中使用结构体也可以实现其他编程语言中的继承。 package main import "fmt" // Animal 动物 type Animal struct { name string } func(a *Animal) run() { fmt.Printf("%s 会运动! \n", a.name) } // Dog 狗 type Dog struct { Age int8 *Animal // 通过嵌套匿名结构体实现继承 } func(d *Dog) wang() { fmt.Printf("%s 会汪汪汪~ \n", d.name) } func main() { d1 := &Dog{ Age:4, Animal:&Animal{ // 注意嵌套的是结构体指针 name:"阿奇", }, } d1.wang() // 阿奇会汪汪汪~ d1.run() // 阿奇会运动! } */ // 自定义类型 和 类型别名的打印结果 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 // 结构体实例化方法1 var p1 person p1.name = "张三" p1.city = "北京" p1.age = 18 fmt.Printf("p1=%v \n", p1) // p1={张三 北京 18} fmt.Printf("p1=%#v \n", p1) // p1=main.person{name:"张三",city:"北京",age:18} // 结构体实例化方法2 var p2 = new(person) p2.name = "张三" p2.city = "北京" p2.age = 20 fmt.Printf("%T \n", p2) // *main.person fmt.Printf("p2=%#v \n", p2) //p2=&main.person{name:"张三",city:"北京",age:20} // 结构体实例化方法3 p3 := &person{} fmt.Printf("%T \n", p3) // *main.person fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"",city:"",age:0} p3.name = "张三" p3.city = "北京" p3.age = 20 // (*p3).age = 50 // 这样也是可以的 fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"张三",city:"北京",age:20} // 打印结构体的信息 pp := PerSon{ name: "小王子", age: 25, } pp.printInfo() // 姓名:小王子 年龄:25 // 值类型接收者和指针类型接收者 fmt.Println("值类型接收者和指针类型接收者运行结果:") p2p := PerSon{ name: "小王子", age: 25, } p2p.printInfo() p2p.setInfo("张三", 20) p2p.printInfo() /* // 上面的运行结果是: 值类型接收者和指针类型接收者运行结果: 姓名:小王子 年龄:25 姓名:张三 年龄:20 */ // 给任意类型添加个方法 println() var m1 zsInt m1.SayHello() // Hello, 我是一个int... m1 = 100 fmt.Printf("%#v %T \n", m1, m1) // 100 main.zsInt // 匿名字段结构体 println() pm := PersonMan{ "小王子", 18, } fmt.Printf("%#v \n", pm) // main.PersonMan{string:"小王子", int:18} fmt.Println(pm.string, pm.int) // 小王子 18 // 嵌套结构体 println() user1 := User{ Name: "张三", Gender: "男", Address: Address{ Province: "广东", City: "深圳", }, } fmt.Printf("user1=%#v \n", user1) // 结果是:user1=main.User{Name:"张三",Gender:"男",Address:main.Address{Province:"广东",City:"深圳"}} // 嵌套匿名结构体 println() var user2 UserT user2.Name = "张三" user2.Gender = "男" user2.Address.Province = "广东" // 通过匿名结构体.字段名访问 user2.City = "深圳" // 直接访问匿名结构体的字段名 fmt.Printf("user2=%#v \n", user2) // 结果是:user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}} // 关于结构体的继承 println() d1 := &Dog{ Age: 4, Animal: &Animal{ // 注意嵌套的是结构体指针 name: "阿奇", }, } d1.wang() // 阿奇会汪汪汪~ d1.run() // 阿奇会运动! // 发现这个用法和Python中类的继承用法是一样的,继承父类的方法和属性都可以通过点的方式去调用。 /* 以上代码的全部执行结果如下: 自定义类型的结果是 type of a:main.newInt 类型别名的结果是 type of b:int p1={张三 北京 18} p1=main.person{name:"张三", city:"北京", age:18} *main.person p2=&main.person{name:"张三", city:"北京", age:20} *main.person 小王子 18 user1=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}} user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}} 阿奇 会汪汪汪~ 阿奇 会运动! */ }

posted @   liujiacai  阅读(21)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· 百万级群聊的设计实践
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
历史上的今天:
2019-01-16 (转)Python 实现双向链表(图解)
2018-01-16 (转)linux正则表达式详解
点击右上角即可分享
微信分享提示