Go语言学习笔记(八)------结构（struct）与方法（method）

一、结构体定义

1.Go 通过类型别名（alias types）和结构体的形式支持用户自定义类型，或者叫定制类型。结构体也是值类型，因此可以通过 new 函数来创建。组成结构体类型的那些数据称为字段（fields）。每个字段都有一个类型和一个名字；在一个结构体中，字段名字必须是唯一的。结构体定义的一般方式如下：

type identifier struct {
field1 type1
field2 type2
...
}

type T struct {a, b int} 也是合法的语法，它更适用于简单的结构体。结构体里的字段都有 名字，像 field1、field2 等，如果字段在代码中从来也不会被用到，那么可以命名它为 _。结构体的字段可以是任何类型，甚至是结构体本身，也可以是函数或者接口。可以声明结构体类型的一个变量，然后像下面这样给它的字段赋值：

var s T
s.a = 5
s.b = 8

2.使用 new 函数给一个新的结构体变量分配内存，它返回指向已分配内存的指针： var t *T = new(T) ，如果需要可以把这条语句放在不同的行（比如定义是包范围的，但是分配却没有必要在开始就做），惯用方法是： t := new(T) ，变量 t 是一个指向 T 的指针，此时结构体字段的值是它们所属类型的零值。声明 var t T 也会给 t 分配内存，并零值化内存，但是这个时候 t 是类型T。在这两种方式中， t 通常被称做类型 T 的一个实例（instance）或对象（object）。

3.使用点号符给字段赋值： structname.fieldname = value 。同样的，使用点号符可以获取结构体字段的值：structname.fieldname 。在 Go 语言中这叫 选择器（selector）。无论变量是一个结构体类型还是一个结构体类型指针，都使用同样的选择器符（selector-notation） 来引用结构体的字段：

type myStruct struct { i int }
var v myStruct // v是结构体类型变量
var p *myStruct // p是指向一个结构体类型变量的指针
v.i
p.i

4.初始化一个结构体实例（一个结构体字面量：struct-literal）的更简短和惯用的方式如下，类型 strcut1 在定义它的包 pack1 中必须是唯一的，它的完全类型名是： pack1.struct1 。&struct1{a, b, c} 是一种简写，底层仍然会调用 new () ，这里值的顺序必须按照字段顺序来写。表达式 new(Type)和 &Type{} 是等价的：

ms := &struct1{10, 15.5, "Chris"} // 此时ms的类型是 *struct1

或者：

var ms struct1
ms = struct1{10, 15.5, "Chris"}

5.时间间隔（开始和结束时间以秒为单位）是使用结构体的一个典型例子：

type Interval struct {
start int
end int
}

初始化方式：

intr := Interval{0, 3} (A)
intr := Interval{end:5, start:1} (B)
intr := Interval{end:5} (C)

在（A）中，值必须以字段在结构体定义时的顺序给出，& 不是必须的。（B）显示了另一种方式，字段名加一个冒号放在值的前面，这种情况下值的顺序不必一致，并且某些字段还可以被忽略掉，就像（C）中那样。

6.示例：显示了一个结构体 Person，一个方法，方法有一个类型为 *Person 的参数（因此对象本身是可以被改变的），以及三种调用这个方法的不同方式：

package main
import (
"fmt"
"strings"
)
type Person struct {
firstName string
lastName string
}
//指针传入地址，可以对该地址的值进行更改，从而改变原对象，而传入对象是传入复制的值，则函数生命周期结束该值消失，不会影响原对象，除非赋值。
func upPerson(p *Person) {
p.firstName = strings.ToUpper(p.firstName)
p.lastName = strings.ToUpper(p.lastName)
}
func main() {
// 1-struct as a value type:
var pers1 Person
pers1.firstName = "Chris"
pers1.lastName = "Woodward"
upPerson(&pers1)
fmt.Printf("The name of the person is %s %s\n", pers1.firstName, pers1.lastName)
// 2—struct as a pointer:
pers2 := new(Person)
pers2.firstName = "Chris"
pers2.lastName = "Woodward"
(*pers2).lastName = "Woodward" // 这是合法的
upPerson(pers2)
fmt.Printf("The name of the person is %s %s\n", pers2.firstName, pers2.lastName)
// 3—struct as a literal:
pers3 := &Person{"Chris","Woodward"}
upPerson(pers3)
fmt.Printf("The name of the person is %s %s\n", pers3.firstName, pers3.lastName)
}

7.递归结构体：结构体类型可以通过引用自身来定义。这在定义链表或二叉树的元素（通常叫节点）时特别有用，此时节点包含指向临
近节点的链接（地址）。链表中的第一个元素叫 head ，它指向第二个元素；最后一个元素叫 tail ，它没有后继元素，所以它的 su 为 nil
值。当然真实的链接会有很多数据节点，并且链表可以动态增长或收缩。

type Node struct {
data float64
su *Node
}

以定义一个双向链表，它有一个前趋节点 pr 和一个后继节点 su ：

type Node struct {
pr *Node
data float64
su *Node
}

8.二叉树中每个节点最多能链接至两个节点：左节点（le）和右节点（ri），这两个节点本身又可以有左右节点，依次类推。树的顶层节点叫根节点（root），底层没有子节点的节点叫叶子节点（leaves），叶子节点的 le 和 ri 指针为 nil值。在 Go 中可以如下定义二叉树：

type Tree strcut {
le *Tree
data float64
ri *Tree
}

9.结构体转换：Go 中的类型转换遵循严格的规则。当为结构体定义了一个 alias 类型时，此结构体类型和它的 alias 类型都有相同的底层
类型，它们可以如示例那样互相转换：

package main
import "fmt"
type number struct {
	f float32
}
type nr number //别名类型
func main() {
	a := number{5.0}
	b := nr{5.0}
	// var i float32 = b // compile-error: cannot use b (type nr) as type float32 in assignment
	// var i = float32(b) // compile-error: cannot convert b (type nr) to type float32
	// var c number = b // compile-error: cannot use b (type nr) as type number in assignment
	// needs a conversion:
	var c = number(b)
	fmt.Println(a, b, c)
}

二、使用工厂方法创建结构体实例

1.Go 语言不支持面向对象编程语言中那样的构造子方法，但是可以很容易的在 Go 中实现 “构造子工厂”方法。为了方便通常会为类型定义一个工厂，按惯例，工厂的名字以 new 或 New 开头。假设定义了如下的 File 结构体类型：

type File struct {
fd int // 文件描述符
name string // 文件名
}

下面是这个结构体类型对应的工厂方法，它返回一个指向结构体实例的指针：

func NewFile(fd int, name string) *File {
if fd < 0 {
return nil
}
return &File{fd, name}
}

然后这样调用它：f := NewFile(10, "./test.txt")， Go 语言中常常像上面这样在工厂方法里使用初始化来简便的实现构造函数。结构体类型T的一个实例占用了多少内存，可以使用： size := unsafe.Sizeof(T{}) 。

2.强制使用工厂方法：通过应用可见性规则可以禁止使用 new 函数，强制用户使用工厂方法，从而使类型变成私有的，就像在面向对象语言中那样。

type matrix struct {
...
}
func NewMatrix(params) *matrix {
m := new(matrix) // 初始化 m
return m
}

在其他包里使用工厂方法：

package main
import "matrix"
...
wrong := new(matrix.matrix) // 编译失败（matrix 是私有的）
right := matrix.NewMatrix(...) // 实例化 matrix 的唯一方式

三、使用自定义包中的结构体

main.go 使用了一个结构体，它来自 struct_pack 下的包 structPack。

package structPack
type ExpStruct struct {
Mi1 int
Mf1 float32
}

主程序：

package main
import (
"fmt"
"./struct_pack/structPack"
)
func main() {
struct1 := new(structPack.ExpStruct)
struct1.Mi1 = 10
struct1.Mf1 = 16.
fmt.Printf("Mi1 = %d\n", struct1.Mi1)
fmt.Printf("Mf1 = %f\n", struct1.Mf1)
}

四、带标签的结构体

结构体中的字段除了有名字和类型外，还可以有一个可选的标签（tag）：它是一个附属于字段的字符串，可以是文档或其他的重要标记。标签的内容不可以在一般的编程中使用，只有包 reflect 能获取它。我们将在下一节中深入的探讨 reflect 包，它可以在运行时自省类型、属性和方法，比如：在一个变量上调用 reflect.TypeOf()可以获取变量的正确类型，如果变量是一个结构体类型，就可以通过 Field 来索引结构体的字段，然后就可以使用 Tag属性。

package main
import (
"fmt"
"reflect"
)
type TagType struct { // tags
field1 bool "An important answer"
field2 string "The name of the thing"
field3 int "How much there are"
}
func main() {
tt := TagType{true, "Barak Obama", 1}
for i := 0; i < 3; i++ {
refTag(tt, i)
}
}
func refTag(tt TagType, ix int) {
ttType := reflect.TypeOf(tt)
ixField := ttType.Field(ix) 
fmt.Printf("%v\n", ixField.Tag) //打印tag信息
}

输出：

An important answer
The name of the thing
How much there are

五、 匿名字段和内嵌结构体

1.结构体可以包含一个或多个 匿名（或内嵌）字段，即这些字段没有显式的名字，只有字段的类型是必须的，此时类型就是字段的名字，在一个结构体中对于每一种数据类型只能有一个匿名字段。匿名字段本身可以是一个结构体类型，即 结构体可以包含内嵌结构体。Go 语言中的继承是通过内嵌或组合来实现的，所以可以说，在 Go 语言中，相比较于继承，组合更受青睐。

package main
import "fmt"
type innerS struct {
	in1 int
	in2 int
}
type outerS struct {
	b int
	c float32
	int // anonymous field匿名字段
	innerS //anonymous field匿名字段
}
func main() {
	outer := new(outerS)
	outer.b = 6
	outer.c = 7.5
	outer.int = 60
	outer.in1 = 5
	outer.in2 = 10
	fmt.Printf("outer.b is: %d\n", outer.b)
	fmt.Printf("outer.c is: %f\n", outer.c)
	fmt.Printf("outer.int is: %d\n", outer.int)
	fmt.Printf("outer.in1 is: %d\n", outer.in1)
	fmt.Printf("outer.in2 is: %d\n", outer.in2)
	// 使用结构体字面量
	outer2 := outerS{6, 7.5, 60, innerS{5, 10}}
	fmt.Println("outer2 is:", outer2)
}

输出：

outer.b is: 6
outer.c is: 7.500000
outer.int is: 60
outer.in1 is: 5
outer.in2 is: 10
outer2 is:{6 7.5 60 {5 10}}

2.结构体也是一种数据类型，所以它也可以作为一个匿名字段来使用，外层结构体通过outer.in1 直接进入内层结构体的字段，内嵌结构体甚至可以来自其他包。内层结构体被简单的插入或者内嵌进外层结构体。这个简单的“继承”机制提供了一种方式，使得可以从另外一个或一些类型继承部分或全部实现。

package main
import "fmt"
type A struct {
ax, ay int
}
type B struct {
A
bx, by float32
}
func main() {
b := B{A{1, 2}, 3.0, 4.0}
fmt.Println(b.ax, b.ay, b.bx, b.by)
fmt.Println(b.A)
}

输出：

1 2 3 4
{1 2}

3.两个字段拥有相同的名字（可能是继承来的名字）：1. 外层名字会覆盖内层名字（但是两者的内存空间都保留），这提供了一种重载字段或方法的方式；2. 如果相同的名字在同一级别出现了两次，如果这个名字被程序使用了，将会引发一个错误（不使用没关系）。没有
办法来解决这种问题引起的二义性，必须由程序员自己修正。

六、方法

1.在 Go 语言中，结构体就像是类的一种简化形式，：Go 方法是作用在接收者（receiver）上的一个函数，接收者是某种类型的变量。因此方法是一种特殊类型的函数。接收者类型可以是（几乎）任何类型，不仅仅是结构体类型：任何类型都可以有方法，甚至可以是函数类型，可以是int、bool、string 或数组的别名类型。但是接收者不能是一个接口类型，因为接口是一个抽象定义，但是方法却是具体实现。最后接收者不能是一个指针类型，但是它可以是任何其他允许类型的指针。

2.在 Go 中，类型的代码和绑定在它上面的方法的代码可以不放置在一起，它们可以存在在不同的源文件，唯一的要求是：它们必须是同一个包的。类型 T（或 *T）上的所有方法的集合叫做类型 T（或 *T）的方法集。

3.方法是函数，所以同样的，别名类型没有原始类型上已经定义过的方法。不允许方法重载，即对于一个类型只能有一个给定名称的方法。但是如果基于接收者类型，是有重载的：具有同样名字的方法可以在 2 个或多个不同的接收者类型上存在，比如在同一个包里这么做是允许的：

func (a *denseMatrix) Add(b Matrix) Matrix
func (a *sparseMatrix) Add(b Matrix) Matrix

4.方法名之前， func 关键字之后的括号中指定 receiver。如果 recv 是 receiver 的实例，Method1 是它的方法名，那么方法调用遵循传统的 object.name 选择器符号：recv.Method1()。如果 recv 是一个指针，Go 会自动解引用。定义方法的一般格式如下：
func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }

如果方法不需要使用 recv 的值，可以用 _ 替换它，比如：
func (_ receiver_type) methodName(parameter_list) (return_value_list) { ... }
recv 就像是面向对象语言中的 this 或 self ，但是 Go 中并没有这两个关键字。随个人喜好，你可以使用 this 或self 作为 receiver 的名字。下面是一个结构体上的简单方法的例子：

package main
import "fmt"
type TwoInts struct {
	a int
	b int
}
func main() {
	two1 := new(TwoInts)
	two1.a = 12
	two1.b = 10
	fmt.Printf("The sum is: %d\n", two1.AddThem())
	fmt.Printf("Add them to the param: %d\n", two1.AddToParam(20))
	two2 := TwoInts{3, 4}
	fmt.Printf("The sum is: %d\n", two2.AddThem())
}
func (tn *TwoInts) AddThem() int {
	return tn.a + tn.b
}
func (tn *TwoInts) AddToParam(param int) int {
	return tn.a + tn.b + param
}

非结构体示例：

package main
import "fmt"
type IntVector []int
func (v IntVector) Sum() (s int) {
for _, x := range v {
s += x
}
return
}
func main() {
fmt.Println(IntVector{1, 2, 3}.Sum()) // 输出是6
}

5.类型与方法必须在同一个包，不在同一个包的话有一个间接的方式：可以先定义该类型（比如：int 或 float）的别名类型，然后再为别名类型定义方法。或者像下面这样将它作为匿名类型嵌入在一个新的结构体中。当然方法只在这个别名类型上有效。

package main
import (
"fmt"
"time"
)
type myTime struct {
time.Time //anonymous field
}
func (t myTime) first3Chars() string {
return t.Time.String()[0:3]
}
func main() {
m := myTime{time.Now()}
// 调用匿名Time上的String方法
fmt.Println("Full time now:", m.String())
// 调用myTime.first3Chars
fmt.Println("First 3 chars:", m.first3Chars())
}
/* Output:
Full time now: Mon Oct 24 15:34:54 Romance Daylight Time 2011
First 3 chars: Mon
*/

6.函数和方法的区别：函数将变量作为参数：Function1(recv)，方法在变量上被调用：recv.Method1()。在接收者是指针时，方法可以改变接收者的值（或状态），这点函数也可以做到（当参数作为指针传递，即通过引用调用时，函数也可以改变参数的状态）。不要忘记 Method1 后边的括号 ()，接收者必须有一个显式的名字，这个名字必须在方法中被使用。receiver_type 叫做 （接收者）基本类型，这个类型必须在和方法同样的包中被声明。

package main
import (
"fmt"
)
type B struct {
thing int
}
func (b *B) change() { b.thing = 1 }
func (b B) write() string { return fmt.Sprint(b) }
func main() {
var b1 B // b1是值
b1.change()
fmt.Println(b1.write())
b2 := new(B) // b2是指针
b2.change()
fmt.Println(b2.write())
}

7. Point3 是作为值传递给方法的，因此传递的是它的拷贝，这在 Go 中是合法的。也可以在指向这个类型的指针上调用此方法（会自动解引用）。假设 p3 定义为一个指针： p3 := &Point{ 3, 4, 5} ，可以使用 p3.Abs() 来替代 (*p3).Abs() 。对于类型 T，如果在 *T 上存在方法 Meth() ，并且 t 是这个类型的变量，那么 t.Meth() 会被自动转换为 (&t).Meth() ，也就是说同一类型下，指针方法类型可以相互调用。

type Point3 struct { x, y, z float64 }
// A method on Point3
func (p Point3) Abs() float64 {
return math.Sqrt(p.x*p.x + p.y*p.y + p.z*p.z)
}

8.对于方法和未导出字段，提供 getter 和 setter 方法。对于 setter 方法使用 Set 前缀，对于getter 方法只使用成员名。

//person2.go
package person
type Person struct {
firstName string
lastName string
}
func (p *Person) FirstName() string { //使用首字母大写的getter方法
return p.firstName
}
func (p *Person) SetFirstName(newName string) { //以Set开头的setter方法
p.firstName = newName
}

//use_person2.go
package main
import (
"./person"
"fmt"
)
func main() {
p := new(person.Person)
// p.firstName undefined
// (cannot refer to unexported field or method firstName)
// p.firstName = "Eric"
p.SetFirstName("Eric") //设置名字
fmt.Println(p.FirstName()) // Output: Eric读取输出
}

9.并发访问对象：对象的字段（属性）不应该由 2 个或 2 个以上的不同线程在同一时间去改变。如果在程序发生这种情况，为了安全并发
访问，可以使用包 sync 中的方法。在后面我们会通过 goroutines 和 channels 探索另一种方式。

10.当一个匿名类型被内嵌在结构体中时，匿名类型的可见方法也同样被内嵌，这在效果上等同于外层类型 继承了这些方法：将父类型放在子类型中来实现亚型。假定有一个 Engine 接口类型，一个 Car 结构体类型，它包含一个 Engine 类型的匿名字段：

type Engine interface {
Start()
Stop()
}
type Car struct {
Engine
}

继承匿名类型方法：

func (c *Car) GoToWorkIn() {
// get in car
c.Start()
// drive to work
c.Stop()
// get out of car
}

示例：

package main
import (
	"fmt"
	"math"
)
type Point struct {
	x, y float64
}
func (p *Point) Abs() float64 {
	return math.Sqrt(p.x*p.x + p.y*p.y)
}
type NamedPoint struct {
	Point
	name string
}
func main() {
	n := &NamedPoint{Point{3, 4}, "Pythagoras"}
	fmt.Println(n.Abs()) // 打印5
}

当然类型可以有只作用于本身实例而不作用于内嵌“父”类型上的方法，可以覆写方法（像字段一样）：和内嵌类型方法具有同样名字的外层类型的方法会覆写内嵌类型对应的方法，从而使用外嵌方法。在method4.go 中添加，现在 fmt.Println(n.Abs()) 会打印 500 ：

func (n *NamedPoint) Abs() float64 {
return n.Point.Abs() * 100.
}

结构体内嵌和自己在同一个包中的结构体时，可以彼此访问对方所有的字段和方法。

11.有两种方法来实现在类型中嵌入功能：A：聚合（或组合）：包含一个所需功能类型的具名字段。为了使这些概念具体化，假设有一个 Customer 类型，我们想让它通过 Log 类型来包含日志功能， Log 类型只是简单地包含一个累积的消息（当然它可以是复杂的）。如果想让特定类型都具备日志功能，你可以实现一个这样的 Log 类型，然后将它作为特定类型的一个字段，并提供 Log() ，它返回这个日志的引用。

package main
import (
"fmt"
)
type Log struct {
msg string
}
type Customer struct {
Name string
log *Log
}
func main() {
c := new(Customer)
c.Name = "Barak Obama"
c.log = new(Log)
c.log.msg = "1 - Yes we can!"
// shorter
c = &Customer{"Barak Obama", &Log{"1 - Yes we can!"}}
// fmt.Println(c) &{Barak Obama 1 - Yes we can!}
c.Log().Add("2 - After me the world will be a better place!")
//fmt.Println(c.log)
fmt.Println(c.Log())
}
func (l *Log) Add(s string) {
l.msg += "\n" + s
}
func (l *Log) String() string {
return l.msg
}
func (c *Customer) Log() *Log {
return c.log
}

B：内嵌：内嵌（匿名地）所需功能类型。

package main
import (
"fmt"
)
type Log struct {
msg string
}
type Customer struct {
Name string
Log
}
func main() {
c := &Customer{"Barak Obama", Log{"1 - Yes we can!"}}
c.Add("2 - After me the world will be a better place!")
fmt.Println(c)
}
func (l *Log) Add(s string) {
l.msg += "\n" + s
}
func (l *Log) String() string {
return l.msg
}
func (c *Customer) String() string {
return c.Name + "\nLog:" + fmt.Sprintln(c.Log)
}

12.多重继承：在 Go 语言中，通过在类型中嵌入所有必要的父类型，可以很简单的实现多重继承。

package main
import (
"fmt"
)
type Camera struct{}
func (c *Camera) TakeAPicture() string {
return "Click"
}
type Phone struct{}
func (p *Phone) Call() string {
return "Ring Ring"
}
type CameraPhone struct {
Camera
Phone
}
func main() {
cp := new(CameraPhone)
fmt.Println("Our new CameraPhone exhibits multiple behaviors...")
fmt.Println("It exhibits behavior of a Camera: ", cp.TakeAPicture())
fmt.Println("It works like a Phone too: ", cp.Call())
}

七、类型的 String() 方法和格式化描述符

1.使用 String() 方法来定制类型的字符串形式的输出，如果类型定义了 String() 方法，它会被用在 fmt.Printf() 中生成默认的输出：等同于使用格式化描述符 %v 产生的输出。还有 fmt.Print() 和 fmt.Println() 也会自动使用 String() 方法。

package main
import (
"fmt"
"strconv"
)
type TwoInts struct {
a int
b int
}
func main() {
two1 := new(TwoInts)
two1.a = 12
two1.b = 10
fmt.Printf("two1 is: %v\n", two1)
fmt.Println("two1 is:", two1)
fmt.Printf("two1 is: %T\n", two1)
fmt.Printf("two1 is: %#v\n", two1)
}
func (tn *TwoInts) String() string {
return "(" + strconv.Itoa(tn.a) + "/" + strconv.Itoa(tn.b) + ")"
}

输出：

two1 is: (12/10)
two1 is: (12/10)
two1 is: *main.TwoInts
two1 is: &main.TwoInts{a:12, b:10}

当你广泛使用一个自定义类型时，最好为它定义 String() 方法。从上面的例子也可以看到，格式化描述符 %T 会给出类型的完全规格， %#v 会给出实例的完整输出，包括它的字段（在程序自动生成 Go 代码时也很有用）。

2.不要在 String() 方法里面调用涉及 String() 方法的方法，它会导致意料之外的错误，比如下面的例子，它导致了一个无限递归调用（ TT.String() 调用 fmt.Sprintf ，而 fmt.Sprintf 又会反过来调用 TT.String() ...），很快就会导致内存溢出。

八、垃圾回收和 SetFinalizer

Go 开发者不需要写代码来释放程序中不再使用的变量和结构占用的内存，在 Go 运行时中有一个独立的进程，即垃圾收集器（GC），会处理这些事情，它搜索不再使用的变量然后释放它们的内存。可以通过 runtime 包访问 GC 进程。通过调用 runtime.GC() 函数可以显式的触发 GC，但这只在某些罕见的场景下才有用，比如当内存资源不足时调用runtime.GC() ，它会在此函数执行的点上立即释放一大片内存，此时程序可能会有短时的性能下降（因为 GC 进程在执行）。
如果想知道当前的内存状态，可以使用：

// fmt.Printf("%d\n", runtime.MemStats.Alloc/1024)
// 此处代码在 Go 1.5.1下不再有效，更正为
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("%d Kb\n", m.Alloc / 1024)

上面的程序会给出已分配内存的总量，单位是 Kb。进一步的测量参考 文档页面。如果需要在一个对象 obj 被从内存移除前执行一些特殊操作，比如写到日志文件中，可以通过如下方式调用函数来实现：
runtime.SetFinalizer(obj, func(obj *typeObj))
func(obj *typeObj) 需要一个 typeObj 类型的指针参数 obj ，特殊操作会在它上面执行。 func 也可以是一个匿名函数。在对象被 GC 进程选中并从内存中移除以前， SetFinalizer 都不会执行，即使程序正常结束或者发生错误。