golang学习笔记4——结构体
结构体格式
golang中的结构体格式如下：
type 结构体名称 struct {
字段名 字段类型
字段名 字段类型
}
下面定义一个结构体Point，有坐标x, y两个整型字段：
type Point struct {
x int
y int
}
同种类型的字段可以写在一行，如下代码：
type Color struct {
r, g, b byte
}
结构体的初始化
结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存。因此必须在定义结构体并实例化后才能使用结构体的字段。
如下代码所示：
package main
import "fmt"
type Point struct {
x int
y int
}
func main() {
var p Point // 或者 p := Point{}
p.x = 1
p.y = 0
// 打印：{1 0}
fmt.Println(p)
}
可以直接使用.来访问结构体的成员变量。
除了使用上面的方式声明并初始化结构体外，还可以使用new关键字，如下代码所示：
package main
import "fmt"
type Point struct {
x int
y int
}
func main() {
p := new(Point) // 也可以使用 p := &Point{}
p.x = 1
p.y = 0
fmt.Println(p)
}
与var p Point这种方式不同的是，使用new关键字创建的是Point类型的指针变量，golang中同样可以使用.来访问结构体指针的成员变量。
也可以在声明结构体变量时直接初始化：
func main() {
p := Point{
x: 1,
y: 0,
}
fmt.Println(p)
}
下面的代码中定义了两个结构体：猫和人，人养了一只宠物，代码如下：
package main
import "fmt"
// 结构体 猫
type Cat struct {
Name string
Weight float32
Color string
}
// 结构体 人
type Person struct {
Name string
Age int
// 养了一只猫
Pet *Cat
}
func main() {
// 初始化一只猫的指针
pet := &Cat{
Name: "kenny",
Weight: 20.3,
Color: "white",
}
// 初始化一个人
person := Person{
Name: "zhangsan",
Age: 25,
Pet: pet,
}
fmt.Println(person)
}
匿名结构体
// 结构体作为函数参数
func test(msg *struct {
ID string
Name string
Age int
}) {
fmt.Printf("id: %v, name: %v, age: %v", msg.ID, msg.Name, msg.Age)
}
func main() {
// 调用函数，传入匿名的结构体
test(&struct {
ID string
Name string
Age int
}{
"asdfasdf",
"wangwu",
25,
})
// 打印结果：id: asdfasdf, name: wangwu, age: 25
}
模拟构造函数
golang没有Java中的类的概念，自然也没有类的构造方法，但是可以模拟结构体的构造函数，比如如下代码：
// 结构体： 猫
type Cat struct {
Name string
Color string
}
// 模拟猫的构造函数，传入姓名
func NewCatWithName(name string) *Cat {
return &Cat{
Name: name,
}
}
// 模拟猫的构造函数，传入猫的颜色
func NewCatWithColor(c string) *Cat {
return &Cat{
Color: c,
}
}
func main() {
// 调用“构造函数”创建两个猫
c1 := NewCatWithColor("black")
c2 := NewCatWithName("kenny")
fmt.Println(c1, c2)
}
模拟继承
golang中在一个结构体中嵌入另一个结构体，来完成类似于面向对象编程中的类的继承，如下代码：
// 结构体 表示动物
type Animal struct {
Color string
}
// 结构体 猫
type Cat struct {
Animal // 这里嵌入了Animal这个结构体，类似于Cat继承了Animal
Name string
}
func main() {
cat := Cat{}
// Cat类中没有声明Color，但是由于嵌入了Animal，所以也有了Color字段
cat.Color = "black"
cat.Name = "haha"
fmt.Println(cat)
}
给结构体添加方法
在面向对象编程中，我们除了给类添加成员变量，还可以为类添加方法，在golang中定义结构体时，只能定义结构体中的成员变量，要为结构体添加方法，只能使用函数来实现，如下代码：
// 定义结构体 猫
type Cat struct {
Color string
}
// 为猫添加一个Eat()方法
func (c *Cat) Eat() {
fmt.Printf("The %s cat is eating...\n", c.Color)
}
func main() {
cat := &Cat{
Color: "black",
}
// The black cat is eating...
cat.Eat()
}
上面的代码为猫这个结构体添加了一个Eat方法，在定义Eat函数时，func后面紧接着的是(c *Cat)，这个(c *Cat)叫做接收器，表示该函数作用的对象，因为是*Cat，所以表示Eat方法作用于Cat指针上，于是在main函数里，初始化了一个cat指针，就可以直接使用cat.Eat()来调用Eat函数了。
golang里的接收器分为两种：指针类型的接收器和非指针类型的接收器。
上面的代码中展示的是指针类型的接收器，其实也可以定义非指针类型的接收器，如下代码：
// 点，包含两个坐标值
type Point struct {
X int
Y int
}
// 非指针类型的接收器
func (p Point) Add(a, b int) Point {
return Point{
X: p.X + a,
Y: p.Y + b,
}
}
func main() {
p := Point{
X: 0,
Y: 0,
}
p1 := p.Add(1, 1)
fmt.Println(p1)
}
在上面的代码中，Add是Point的一个方法，该方法接受两个整型数据，返回一个Point，Add函数的接收器是一个Point结构体，而非结构体的指针类型。
指针类型接收器与非指针类型接收器的区别：
- 小对象比较适合使用非指针类型的接收器，因为其复制时速度较快
- 大对象比较适合使用指针类型的接收器，因为大对象的复制性能较差，使用指针速度更快
给基本数据类型添加方法
// 定义一个MyInt类型（就是int型）
type MyInt int
// 给MyInt型的变量添加一个isZero方法
func (i MyInt) isZero() bool {
return i == 0
}
func main() {
var i MyInt = 3
fmt.Println(i.isZero())
}
方法和函数的统一调用
这里说的方法，指的是与某个结构体关联起来的函数，该函数具有接收器；而普通的使用func定义的，称为函数。下面的代码展示了方法与函数的统一调用：
type Person struct {
}
// 定义Person的sing方法
func (p *Person) sing(song string) {
fmt.Printf("the person is singing %s\n", song)
}
// 定义一个单独的sing函数
func sing(song string) {
fmt.Printf("call function sing, the song is %s\n", song)
}
func main() {
// 定义f
var f func(string)
p := &Person{}
// 将f赋值为Person的成员方法
f = p.sing
f("My heart will go on")
// 将f赋值为独立的函数
f = sing
f("My heart will go on")
}
上面的代码证明了，如果方法与函数具有相同的签名，则可以使用与它们签名一致的变量保存该方法或函数。
类型内嵌结构体
golang中的结构体在声明时，可以只写字段类型而不写字段名称，这种结构体称为类型内嵌或匿名字段类型内嵌，如下代码所示：
// 定义Data结构体，该结构体字段只有类型没有名称
type Data struct {
string
int
float32
}
func main() {
// 初始化结构体
data := &Data{
string: "zhangsan",
int: 20,
float32: 80.5,
}
// 打印: &{zhangsan 20 80.5}
fmt.Println(data)
}
结构体的内嵌与初始化
下面以一个例子说明结构体的内嵌，房子由门和窗户组成，如下代码：
// 窗户
type Window struct {
Width int
Height int
}
// 门
type Door struct {
Width int
Height int
}
// 房子
type House struct {
Window
Door
}
func main() {
// 初始化House的方式
house := &House{
Window: Window{
Width: 10,
Height: 10,
},
Door: Door{
Width: 20,
Height: 45,
},
}
fmt.Println(house)
}
上面的代码如果把Door这个结构体去掉，而直接把Door的结构写在House里，就成了嵌套的匿名结构体，如下代码：
// 窗户
type Window struct {
Width int
Height int
}
// 房子
type House struct {
Window
// 门直接以内嵌形式声明，而不单独声明结构体
Door struct {
Width int
Height int
}
}
func main() {
house := &House{
Window: Window{
Width: 10,
Height: 10,
},
// 初始化House时给Door赋值的方法如下：
Door: struct {
Width int
Height int
}{
Width: 20,
Height: 45,
},
}
fmt.Println(house)
}