Go 语言中的结构体：定义、初始化与高级用法解析
一、结构体基础
1、什么是结构体
- Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念
- Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性
2、自定义类型
- 在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型
- Go语言中可以使用type关键字来定义自定义类型
- 将myInt定义为int类型，通过type关键字的定义，myInt就是一种新的类型，它具有int的特性
type myInt int3、类型别名
- Golang1.9版本以后添加的新功能
- 类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型
- 就像一个孩子小时候有大名、小名、英文名，但这些名字都是指的是他本人
type TypeAlias = Type
4、自定义类型和类型别名的区别
- 类型别名与自定义类型表面上看只有一个等号的差异
- 结果显示a的类型是main.newInt,表示main包下定义的newInt类型
- b的类型是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
}二、结构体定义
1、基本实例化（方法1）
- 只有当结构体实例化时，才会真正地分配内存，也就是必须实例化后才能使用结构体的字段
- 结构体本身也是一种类型，我们可以像声明内置类型一样使用var 关键字声明结构体类型
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
var p1 person
p1.name = "Snail"
p1.city = "上海"
p1.age = 21
fmt.Printf("p1=%v\n",p1) // p1={Snial 上海 21}
fmt.Printf("p1=%#v\n",p1) //p1 main.person{name:"Snail"，city:"上海",age:21}
}2、new实例化（方法2）
- 我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址
- 从打印的结果中我们可以看出p2是一个结构体指针
- 注意：在Golang中支持对结构体指针直接使用.来访问结构体的成员
- p2.name = "Snail"其实在底层是（*p2）.name = "Snail"
package main
import "fmt"
type persopn struct {
name string
city string
age int
}
func mian() {
var p2 =new(person)
p2.name = "Snail"
p2.age = 21
p2.city = "北京"
fmt.Printf("%T\n", p2) //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"张三", city:"北京", age:20}
}3、&取地址实例化（方法3）
- 使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作
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 = "Snail"
p3.age = 21
p3.city = "上海"
(*p3).age = 20 //这样也是可以的
fmt.Printf("p3=%#v\n",p3) //p3=&main.person{name:"Snail",age:21,city:"上海"}
}4、键值对初始化（方法5）
- 注意：最后一个属性的，要加上
package main
import "fmt"
type person struct {
name string
city stirng
age int
}
func main() {
p4:=person{
name : "Snail",
city : "上海",
age : 21,
}
fmt.Printf("p4=%#v\n",p4) //p4=main.person{name:"Snail",city:"上海",age:18}
}5、值列表初始化（方法5）
- 初始化结构体的时间可以简写，也就是初始化的时候不写键，直接写值
- 必须初始化结构体的所有字段
- 初始值的填充顺序必须与字段在结构体中的声明顺序一致
- 该方式不能和键值初始化方式混用
package main
import "fmt"
type person struct {
nama string
city string
age int
}
func main () {
// 初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值
p7 := &person{
"Snail",
"上海",
23,
}
//p7=&main.person{name:"Snail",city:"上海",age:23}
fmt.Printf("p7=%#v\n", p7)
}6、结构体的匿名字段
- 结构体允许其成员字段在声明是没有字段名而只有类型，这种没有名字的字段就为匿名字段
- 匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个
package main
import "fmt"
type Person struct { //Person结构体 Person类型
string
int
}
func main() {
p1 := Person{
"Snail",
18,
}
fmt.Printf("%#v\n", p1) //main.Person{string:"北京", int:18}
fmt.Println(p1.string, p1.int) //北京 18
}三、嵌套结构体
1、普通嵌套结构体
- 一个结构体中可以嵌套包含另一个结构体或结构体指针
package main
import "fmt"
type Address struct { //Address地址结构体
Province string
City string
}
type User struct { //User用户结构体
Name string
Gender string
Address Address
}
func main() {
user1 := User{
Name : "Snail",
Gender : "男",
Address : Address{
Province : "安徽",
City:"合肥"
}
}
fmt.Printf("user1=%#v\n", user1)
//user1=main.User{Name:" Snail ", Gender:" 男 ", Address:main.Address{Province:"安徽", City:"合肥"}}
}
2、嵌套匿名及结构体
- 注意：当访问结构体或成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找
package main
import "fmt"
type Address struct { //Address 地址结构体
Province string
City string
}
type User struct { //User 用户结构体
Name string
Gender string
Address
}
func main() {
var user2 User
user2.Name = "张三"
user2.Gender = "男"
user2.Address.Province = "广东" //通过匿名结构体.字段名访问
user2.City = "深圳" //直接访问匿名结构体的字段名
fmt.Printf("user2=%#v\n", user2)
//user2=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
}四、结构体方法和接收者
1、结构体说明
- 在go语言中，没有类的概念但是可以给类型（结构体，自定义类型定义方法）
- 所谓方法就是定义了接收者的函数
- Go语言中的方法（Method）是一种作用于特定类型变量的函数
- 这种特定类型变量叫做接收者（Receiver）
- 接收者的概念就类似于其他语言中的this或者self
- 方法的定义格式如下
func (接收者变量 接收者类型) 方法名(参数列表)(返回参数){
函数体
}2、结构体方法和接收者
package main()
import "fmt"
type Person struct {
name string
age int8
}
func (p Person) printInfo() {
fmt.Printf("姓名:%v 年龄:%v", p.name, p.age) // 姓名:Snail 年龄:23
}
func main() {
p1 := Person{
name: "Snail",
age: 23,
}
p1.printInfo() // 姓名:Snail 年龄:23
}3、值类型和指针类型接收者
- 实例1：给结构体Person定义一个方法打印Person的信息
- 1、值类型的接收者
- 当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份
- 在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身
- 2、指针类型的接收者
- 指针类型的接收者由一个结构体的指针组成
- 由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的
- 这种方式就十分接近于其他语言中面向对象的this或者self
package main
import "fmt"
type Person struct {
name string
age int
}
//值类型接受者
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 main() {
p1 := Person{
name: "小王子",
age: 25,
}
p1.printInfo() // 姓名:小王子 年龄:25
p1.setInfo("张三", 20)
p1.printInfo() // 姓名:张三 年龄:20
}
五、结构体继承
- Go 语言中使用结构体也可以实现其他编程语言中的继承
1、普通传值
package main
import "fmt"
type Animal struct { //Animal 动物
name string
}
func (a *Animal) run() {
fmt.Printf("%s 会运动！\n", a.name)
}
type Dog struct { //Dog狗
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() //乐乐会动！
}
2、指针传值
package main
import "fmt"
type Animal struct { //Animal 动物
name string
}
func (a *Animal) run() {
fmt.Printf("%s 会运动！\n", a.name)
}
type Dog struct { //Dog狗
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() //乐乐会动！
}
六、给任意类型添加方法
-
在 Go 语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。
-
举个例子，我们基于内置的 int 类型使用 type 关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
-
注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
package main
import "fmt"
type myInt int
func (m myInt) SayHello() {
fmt.Println("Hello, 我是一个 int。")
}
func main() {
var m1 myInt
m1.SayHello() //Hello, 我是一个 int。
m1 = 100
fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt
}