Golang学习之面向对象编程

一、Golang面向对象编程概念

Golang没有沿袭其他传统编程语言面向对象的概念:没有封装、继承、多态这些概念,但可以通过别的方式来实现这些特性:

  • 封装:通过方法实现
  • 继承:通过匿名字段实现
  • 多态:通过接口实现

二、匿名字段

2.1 匿名字段的概念

一般情况下,定义结构体的时候是字段名与其类型一一对应,实际上Golang支持只提供类型而不写字段名的方式,这就是匿名字段。
匿名字段的简单体验:
当匿名字段也是一个结构体s1且存在于另一个结构体s2的时候,那么s1结构体的全部字段都会被隐式地引入到结构体s2。此时,匿名字段也可以被称为嵌入字段,实现了”继承”的思想。
例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//人
type Person struct {
name string
sex byte
age int
}

//学生
type Student struct {
Person //匿名字段,只有Person类型而没有名字,那么Student默认就包含了Person的所有字段

//学生额外的字段
stuNo int //学号
address string
}

Student中的Person,Person只是个类型而没有给它起名称,所以Person就是匿名字段!Student中的Person会把Person类型中的字段全部引用过来。

2.2 匿名字段初始化

2.2.1 顺序初始化

对应结构体中的字段,一个个给值。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string
}

func main() {
var s1 = Student{
Person: Person{"go", 'M', 11}, //Person本身也是一个结构体,对结构体匿名字段进行初始化需要这样写
stuNo: 0,
address: "Google Inc.",
}
fmt.Println("s1=", s1) //s1= {{go 77 11} 0 Google Inc.}
}

2.2.2 自动推导类型

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string
}

func main() {
s1 := Student{Person{"go", 'M', 11}, 0, "Google Inc."}
fmt.Printf("s1=%+v\n", s1) //s1={Person:{name:go sex:77 age:11} stuNo:0 address:Google Inc.}
}

%+v 信息显示地更加详细!从上例中可以看到,每个字段名也打印了出来。
注意:如果结构体中使用了另一个结构体,就必须显示地带上类型,不然就报错!
例如:

1
2
3
4
func main() {
s2 := Student{{"go", 'M', 11}, 0, ""} //报错:missing type in composite literal ===> 组合字面量中缺少类型
fmt.Println("s2=", s2)
}

{"go", 'M', 11} 前面一定要带上 Person 这个类型!
匿名函数在Golang官方中的叫法是:函数字面量,这里再次看到了字面量这个词语,也可以得知匿名字段也只一个结构体的字面量。

2.2.3 指定成员初始化

指定结构体匿名字段的话,就一层套一层地去写。例如:StructName:StructName{FieldName:Value}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string
}

func main() {
//一层套一层的写法,Person:Person{字段名:值}
s1 := Student{Person: Person{name: "go"}, address: "Google Inc."}
fmt.Printf("s1=%+v\n", s1) //s1={Person:{name:go sex:0 age:0} stuNo:0 address:Google Inc.}
}

2.3 成员操作

跟操作普通结构体的方式一模一样。

2.3.1 方式一

结构体字面量(结构体匿名字段)已经被直接引入了,可以用 . 来访问。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string
}

func main() {
s1 := Student{Person{"go", 'M', 11}, 0, ""}
fmt.Printf("s1.name=%v\n", s1.name) //直接可以使用了
fmt.Printf("s1.sex=%v\n", s1.sex)
fmt.Printf("s1.age=%v\n", s1.age)
fmt.Printf("s1.stuNo=%v\n", s1.stuNo)
fmt.Printf("s1.address=%v\n", s1.address)
}

/*
s1.name=go
s1.sex=77
s1.age=11
s1.stuNo=0
s1.address=
*/

2.3.2 方式二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string
}

func main() {
s1 := Student{Person{"go", 'M', 11}, 0, ""}
s1.name = "Golang" //修改成员的值,也是直接用点"."来操作
s1.address = "Google Inc."
fmt.Printf("s1=%+v\n", s1) //s1={Person:{name:Golang sex:77 age:11} stuNo:0 address:Google Inc.}
}

2.3.3 方式三

结构体中的字面量当做一个整体赋值。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string
}

func main() {
s1 := Student{Person{"go", 'M', 11}, 0, ""}

//Person在Student中是一个结构体,可以被整体赋值
s1.Person = Person{name: "go-lang"} //注意等号"="后面要带上类型,未给值的将把原来的值给覆盖使用其类型的零值

fmt.Printf("s1=%+v\n", s1) //s1={Person:{name:go-lang sex:0 age:0} stuNo:0 address:}
}

注意:当做一个整体赋值的时候,如果有字段没给值,那么就会使用其类型对应的零值覆盖原值

2.4 同名字段

实质上跟作用域的规则一样:能在当前作用域内找到的就用当前作用域内的字段,没有找到才往上去找。
例1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string

name string //和Person中的name同名了
}

func main() {
var s Student
s.name = "Golang"
s.sex = 'M'
s.age = 11
fmt.Printf("s=%+v\n", s)
//s={Person:{name: sex:77 age:11} stuNo:0 address: name:Golang}
}

可以看到Person中的name是空字符串,跟作用域的规则一样:s.name能在Student中找到,那么就用了Student中的name,不会去管Person中的name了;而Student中没有sex这个字段,那么程序就会往上去找,找到了Person中有sex字段,就给Person中的sex字段赋值了。
想要使用Person中的name,就需要显示调用
例2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段,Student默认就包含了Person的所有字段

stuNo int //学号
address string

name string //和Person中的name同名了
}

func main() {
var s Student
s.name = "Golang"
s.sex = 'M' //Student中没有sex这个字段,会往上去找,找到Person中有sex字段
s.age = 11
s.Person.name = "01" //显示调用,指定为Person中的name
s.Person.sex = 'u' //指定调用,这里会覆盖之前的值
s.Person.age = 219
fmt.Printf("s=%+v\n", s)
//s={Person:{name:01 sex:117 age:219} stuNo:0 address: name:Golang}
}

显示调用后,两个name都被指定了,就各管各的了。

2.5 非结构体匿名字段

就是只写数据类型而不写变量名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
type myAddress string //自定义类型,说白了就是给一个类型起个别名

//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
Person //结构体匿名字段
int //普通类型的匿名字段
myAddress //使用自定义类型
}

func main() {
s := Student{Person{"Go", 'M', 11}, 101010, "Google Inc."}
fmt.Printf("s=%+v\n", s)

s.Person = Person{name: "C", sex: 'm'} //当做一个整体赋值
s.int = 999 //直接操作那个类型即可
s.myAddress = "贝尔实验室" //直接操作结构体里的字段即可
fmt.Printf("s=%+v\n", s)
}

/*
运行结果:
s={Person:{name:Go sex:77 age:11} int:101010 myAddress:Google Inc.}
s={Person:{name:C sex:109 age:0} int:999 myAddress:贝尔实验室}
*/

Student 中的 int 字段就是非结构体(普通类型)匿名字段。

2.6 结构体匿名字段的指针类型

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
type myAddress string //自定义类型,说白了就是给一个类型起个别名

//人
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//学生
type Student struct {
*Person //结构体匿名字段的指针类型
int //普通类型的匿名字段
myAddress //使用自定义类型
}

func main() {
//第一种方式,使用取地址符"&"
//Student中的Person是指针类型,这里的Person需要在前面加上取地址符"&"
s := Student{&Person{"Go", 'M', 11}, 101010, "Google Inc."}
fmt.Printf("s=%+v\n", s) //&Person是取内存地址,这样写只会打印出内存地址的值
//需要一个个写才能显示真正的内容
fmt.Println(s.Person.name, s.Person.sex, s.Person.age, s.int, s.myAddress) //Go 77 11 101010 Google Inc.

//第二种方式,new()
var s2 Student
s2.Person = new(Person) //分配一个内存地址,让*Person变成一个指向Person的合法指针
//有合法指向后,即可操作里面的成员
s2.name = "C"
s2.sex = 'm'
s2.age = 48
s2.int = 999 //s2.int不是指针,只是普通类型的匿名字段
s2.myAddress = "贝尔实验室"
fmt.Println(s2.Person.name, s2.Person.sex, s2.Person.age, s2.int, s2.myAddress)
}

/*
运行结果:
s={Person:0xc0000044a0 int:101010 myAddress:Google Inc.}
Go 77 11 101010 Google Inc.
C 109 48 999 贝尔实验室
*/

三、方法

在 Golang 中,方法本质上也是一个函数,它要和自定义类型绑定在一起。绑定了某一个类型的函数,被称为方法。带有接收者的函数叫方法,换言之:为某个类型绑定了一个函数,那个函数就被称为方法。
可以给任意自定义类型添加相应的方法(指针和接口类型除外)。
语法:func (receiver ReceiverType) funcName(params) (results)
receiver:接收者的名称,可任意命名,符合变量命名规则即可。方法要跟自定义类型绑定在一起,被绑定的那个叫接收者。
ReceiverType:接收者的数据类型,可以是T或者*T,但它自身的基类型T不能是接口或指针。

3.1 基本数据类型绑定方法

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//自定义一个类型
type long int

//给long类型绑定一个Add函数,由tmp来接收,tmp就是接收者
//接收者就是传递过来的一个参数,other是调用时小括号里的另一个参数
func (tmp long) Add(other long) long {
return tmp + other
}

func main() {
var a long //定义一个变量a,类型是long
a = 10 //long指向的是int类型,所以可以直接给int类型的值,其他类型是不可以的

//a是一个long类型,long类型绑定了一个Add函数,所以a可以调用long类型中的这个Add函数
//这里的a其实是一个接收者,传递过去一个参数即可
result := a.Add(20)

//注意:Add返回的是一个long类型了
fmt.Printf("result type is : %T, result=%v\n", result, result)
//result type is : main.long, result=30
}

result := a.Add(20) 这行代码中,a 是一个 long 类型的变量,对应地传递给了 long 类型的接收者,20 传递给方法中的形参:

3.2 结构体类型绑定方法

3.2.1 示例:绑定一个方法,实现修改结构体成员值

注意:结构体是值传递,要修改结构体成员的值需要用到指针。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//带有接收者的函数被称为方法,使用类型来调用
//接收者本身就是一个参数
func (tmp Person) PrintInfo() {
fmt.Println("person infos =", tmp)
}

//修改结构体的成员需要用到指针
func (p *Person) SetInfo(name string, sex byte, age int) {
p.name = name
(*p).sex = sex
p.age = age
}

func main() {
//自动推导
p := Person{"go", 'm', 11}
p.PrintInfo() //p本身就是一个参数,传递给tmp这个接收者

//接收者是一个指针类型,需要一个指向合法内存地址的指针
//new()方式
p1 := new(Person)
p1.SetInfo("C", 'M', 48)
p1.PrintInfo()

//取地址符方式
var p2 Person
(&p2).SetInfo("Ada", 'F', 40)
p2.PrintInfo() //没有取地址符在这里也可以
}

/*
运行结果:
person infos = {go 109 11}
person infos = {C 77 48}
person infos = {Ada 70 40}
*/

3.2.2 针对上面例子的反面教材

如果不传递结构体的内存地址,结构体将以值传递的方式进行传参,不同作用域内的结构体是各管各的。
修改3.2.1的代码成如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

func (tmp Person) PrintInfo() {
fmt.Println("person infos =", tmp)
}

//修改结构体的成员需要用到指针
//未使用指针,接收的是一个拷贝过来的副本,在函数中的任何操作都只是在操作副本
func (p Person) SetInfo(name string, sex byte, age int) {
p.name = name
p.sex = sex
p.age = age
fmt.Println("inner SetInfo():", p)
}

func main() {
p1 := Person{"go", 'm', 11}
fmt.Printf("main(), before setting ... ")
p1.PrintInfo()

p1.SetInfo("C", 'M', 48)
fmt.Printf("main(), after setting ... ")
p1.PrintInfo()
}

/*
运行结果:
main(), before setting ... person infos = {go 109 11}
inner SetInfo(): {C 77 48}
main(), after setting ... person infos = {go 109 11}
*/

结构体传参,默认是值传递:只是把一份副本拷贝过去。在SetInfo()函数中的所有操作都只是在操作这个副本,SetInfo()函数结束后,这个副本就被回收了。那么在main()中,是找不到这个副本的,所以依然会使用之前的。
在另外一个函数中想要修改结构体成员的值,必须传址!

3.3 注意事项

3.3.1 ReceiverType接收者的基类型不能是指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
type long int

//接收者不使用的话,可以省略不写
//没问题可以编译通过
func (long) Add(second int) {
}

//

type bigInt *int
//报错:invalid receiver type bigInt (bigInt is a pointer type)
//非法的接收者类型(bigInt是一个指针类型)
func (tmp bigInt) Add(second int) {
}

//这样是能编译通过的
//接收者接收一个内存地址,而long本身它是int类型,不是指针类型
func (tmp *long) SetValue(value int) {
}

func main() {
}

bigInt 是一个接收者类型,它本身是一个 int 指针,而** Golang 规定方法的接收者类型不允许为指针**!

3.3.2 接收者类型不一样,就不同的方法

下例不会出现重复定义的错误:

1
2
3
4
5
6
7
8
9
10
11
type char byte
type long int32

func (c char) test() {
}

func (l long) test() {
}

func main() {
}

3.4 值语义和引用语义

就是值传递与引用传递的区别,值传递称为值语义,引用传递称为引用语义。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

//值传递(值语义),传过来的是实参的一份副本
func (p Person) SetInfoValue(name string, sex byte, age int) {
p.name = name
p.sex = sex
p.age = age

fmt.Printf("SetInfoValue(): p address:%p, p=%v\n", &p, p) //这里的接收者不是一个指针类型,所以取地址要加上取地址符"&"
}

//引用传递(引用语义),接收一个内存地址的实参
func (p *Person) SetInfoPointer(name string, sex byte, age int) {
p.name = name
p.sex = sex
p.age = age

//这里的接收者本身就是一个指针,存放的就是内存地址,无需加取地址符
//取值还是需要加上星花符"*"
fmt.Printf("SetInfoPointer():p address:%p, p=%v\n", p, *p)
}

func main() {
s := Person{"Go", 'M', 11}
fmt.Printf("main(): s address:%p, s=%v\n", &s, s)

//值语义
s.SetInfoValue("C", 'M', 42)

//引用语义,取出内存地址当做参数传递过去
(&s).SetInfoPointer("C", 'M', 42)
}

/*
运行结果:
main(): s address:0xc0000044a0, s={Go 77 11}
SetInfoValue(): p address:0xc000004500, p={C 77 42}
SetInfoPointer():p address:0xc0000044a0, p={C 77 42}
*/

SetInfoValue() 它绑定的接收者是一个普通类型,结构体默认是值传递,所以得到的是一份实参的拷贝,进了这个函数中,main() 中的实参和 SetInfoValue() 中的实参,各管各的了,互不相关。
SetInfoPointer() 它绑定的接收者是一个指针类型,需要的是一个内存地址的实参。得到了变量的内存地址,那么无论哪里修改,都是在修改内存地址中的值,一处修改影响原本的实参。

3.5 方法集

类型的方法集是指:可以被该类型变量调用的所有方法的集合。
用一个变量(value/pointer)调用方法(含匿名字段)不受方法集约束,编译器总能够查找全部方法,并自动转换 receiver 实参。

3.5.1 指针变量的方法集

结构体变量是一个指针变量,它能够调用哪些方法,这些方法就是一个集合,简称:方法集。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

func (p Person) SetInfoValue() {
fmt.Println("SetInfoValue")
}

func (p *Person) SetInfoPointer() {
fmt.Println("SetInfoPointer")
}

func main() {
//初始化一个指针变量
p := &Person{"Golang", 'M', 11} //指针指向内存地址,所以用取地址符"&"

p.SetInfoPointer() //指针变量理所当然能够调用指针接收者的方法

//SetInfoValue()的接收者是一个普通类型变量,但p是一个指针类型变量。此时,Golang内部就会做自动转换
//先把指针变量p,转换成(*p),然后再调用。实际上它的操作就是 (*p).SetInfoValue()
//实参p是一个指针类型变量,但接收者是一个普通类型变量,此时Golang内部就会自动转换
p.SetInfoValue() //经过内部转换,指针变量同时也能调用非指针接收者的方法

//这里手动显示转换,取值符把指针变量变成了普通变量,接收者也是一个普通变量,Golang不会去自动转换了,略微提高了性能
(*p).SetInfoValue()

//手动把指针变量p,转换为普通变量p,也能调用
//Golang内部会去再次做转换
(*p).SetInfoPointer() //取值了,就变成了普通变量
}

/*
运行结果:
SetInfoPointer
SetInfoValue
SetInfoValue
SetInfoPointer
*/

3.5.2 普通变量的方法集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
type Person struct {
name string
sex byte //最终以ASCII码值的方式打印
age int
}

func (p Person) SetInfoValue() {
fmt.Println("SetInfoValue")
}

func (p *Person) SetInfoPointer() {
fmt.Println("SetInfoPointer")
}

func main() {
//普通变量
p := Person{"Golang", 'M', 11} //指针指向内存地址,所以用取地址符"&"

//内部先把普通变量p,转换为&p后再调用
//实际上它是 (&p).SetInfoPointer()
p.SetInfoPointer()

p.SetInfoValue() //p本身就是个普通变量,当然能掉普通接收者类型的方法
}

/*
运行结果:
SetInfoPointer
SetInfoValue
*/

3.5.3 方法集的总结

结构体变量要去调用方法,无需关心结构体变量是指针类型还是普通类型,Golang 非常智能,内部都会去做对应的转换,以适应最终的 ReceiverType

3.6 方法的匿名

使用了嵌入字段,同业也会将那个字段的方法引用过来。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
type Person struct {
name string
sex byte
age int
}

//给Person结构体绑定一个方法
func (p *Person) PrintInfo() {
fmt.Printf("name=%s, sex=%c, age=%d\n", p.name, p.sex, p.age)
}

//Student引用Person结构体
type Student struct {
Person //匿名字段
stuNo int
address string
}

func main() {
s := Student{Person{"Go", 'M', 11}, 1010, "Google Inc."}

//Student结构体引用Person,Person中有PrintInfo()方法,因此Student结构体变量也可以直接调用
s.PrintInfo()
}

/*
运行结果:
name=Go, sex=M, age=11
*/

Student 有对 Person 结构体的引用,Person 结构体绑定了一个方法,既然 Student 引用了 Person 这个结构体,那么同时也会得到 Person 所有的属性和方法。

3.7 同名方法

在 3.3.2 中已经提及过这个概念,接收者不一样,就算方法名一样,那么也是两个不同的方法,只是看起来名字一样而已。查找规则跟作用域原则一致!
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
type Person struct {
name string
sex byte
age int
}

func (p *Person) PrintInfo() {
fmt.Printf("*Person=%+v\n", *p)
}

type Student struct {
Person //匿名字段
stuNo int
address string
}

func (s *Student) PrintInfo() {
fmt.Printf("*Student=%+v\n", *s)
}

func main() {
s := Student{Person{"Go", 'M', 11}, 1010, "Google Inc."}

//查找规则跟作用域原则的一样,先找自己本身
s.PrintInfo()

//只想调用Person的那个PrintInfo(),就需要显示调用
s.Person.PrintInfo()
}

/*
运行结果:
*Student={Person:{name:Go sex:77 age:11} stuNo:1010 address:Google Inc.}
*Person={name:Go sex:77 age:11}
*/

3.8 方法值和方法表达式

3.8.1 方法值

本质上是方法的字面量,将方法的入口(可以简单理解成:函数体)赋值给一个变量,变量保存了这个方法的入口,可以直接使用变量名()方式调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
type Person struct {
name string
sex byte
age int
}

func (p Person) SetValue() {
fmt.Printf("SetValue: p address=%p, p=%+v\n", &p, p) //普通类型变量,格式化地址值需要加取地址符"&"
}

func (p *Person) SetPointer() {
fmt.Printf("SetPointer: p address=%p, p=%+v\n", p, p) //p本身就是指针类型
}

func main() {
p := Person{"Go", 'M', 11}
fmt.Printf("main: p address=%p, p=%+v\n", &p, p)

p.SetPointer() //传统调用方式

pFunc := p.SetPointer //将方法的入口赋值给变量,变量就保存了该方法。这个就是方法值,调用方法时无需再传接收者,因为已经隐藏了接收者
pFunc() //pFunc这个变量保存了一个方法,可以直接加圆括号调用。等价于 p.SetPointer()

//普通数据类型使用方法值也是一样的操作
vFunc := p.SetValue //将方法的入口赋值给一个变量,隐藏了接收者
vFunc() //等价于 p.SetValue()
}

/*
运行结果:
main: p address=0xc0000044a0, p={name:Go sex:77 age:11}
SetPointer: p address=0xc0000044a0, p=&{name:Go sex:77 age:11}
SetPointer: p address=0xc0000044a0, p=&{name:Go sex:77 age:11}
SetValue: p address=0xc000004540, p={name:Go sex:77 age:11}
*/

3.8.2 方法表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
type Person struct {
name string
sex byte
age int
}

func (p Person) SetValue() {
fmt.Printf("SetValue: p address=%p, p=%+v\n", &p, p) //普通类型变量,格式化地址值需要加取地址符"&"
}

func (p *Person) SetPointer() {
fmt.Printf("SetPointer: p address=%p, p=%+v\n", p, p) //p本身就是指针类型
}

func main() {
p := Person{"Go", 'M', 11}
fmt.Printf("main: p address=%p, p=%+v\n", &p, p)

f1 := (*Person).SetPointer //接收者是指针类型,就需要加上星花符"*"
f1(&p) //显示地把实参传递给接收者,等价于 p.SetPointer()

f2 := (Person).SetValue //接收者是普通数据类型
f2(p) //显示地把变量传递给接收者
}

/*
运行结果:
main: p address=0xc0000044a0, p={name:Go sex:77 age:11}
SetPointer: p address=0xc0000044a0, p=&{name:Go sex:77 age:11}
SetValue: p address=0xc000004520, p={name:Go sex:77 age:11}
*/

3.8.3 两者的区别

方法值把接收者的实参给隐藏了起来,方法表达式需要显示传参,只是写法上的不同而已。本质上都是保存了方法的入口,让变量变成一个方法字面量。

四、接口

接口实现了”多态”的思想。接口跟结构体很像,结构体里面放的是成员(属性)、变量,接口里面放的是方法(实际上就是函数)的声明,方法由其他类型实现。
在 Golang 中,接口 interface 是一个自定义类型,接口类型具体描述了一系列方法的集合。(方法由其他类型定义)
接口类型只会展示出它们自己的方法,它不会暴露出它所代表的内部值的结构和支持的基础操作的集合。
Golang 的接口实现了鸭子类型 duck-typing,我不关心这只动物到底是鸟还是鸭子还是鸵鸟,我只要看到它走起来像鸭子、游泳起来像鸭子或者叫起来像鸭子,那么这只动物就是鸭子。总结:不关心数据类型,只关心行为。不关心最终由哪个类型来实现,只关心最终实现了什么行为!

4.1 接口声明

基本语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
type Humaner interface {
SayHi() ReturnType
}
123
```go

注意事项:
1.接口命名习惯以 `er` 结尾。
2.接口只有方法声明,没有实现,没有数据字段。
3.接口可以匿名嵌入其他接口,或嵌入到结构中。
4.声明带返回值的方法时,把返回值类型写在方法名的小括号后面。

### 4.2 接口实现

接口是用来定义行为(方法)的类型。这些被定义的行为不由接口直接实现,而是由用户定义的类型实现。
如果用户定义的类型实现了某个接口类型声明的一组方法,那么这个用户定义的类型的值就可以赋值给这个接口类型的值。这个赋值会把用户定义的类型的值存入接口类型的值。
示例:

```go
//定义接口类型
type Humaner interface {
//方法的声明,没有实现,由别的类型(自定义类型)实现
sayhi()
}

type Student struct {
name string
stuNo int
}

//Student类型实现了sayhi()方法
func (s *Student) sayhi() {
fmt.Printf("Student[%s, %d], say hi.\n", s.name, s.stuNo)
}

type Teacher struct {
address string
group string
}

//Teacher类型实现了sayhi()方法
func (t *Teacher) sayhi() {
fmt.Printf("Teacher[%s, %s], say hi.\n", t.address, t.group)
}

type MyStr string

func (s *MyStr) sayhi() {
fmt.Printf("MyStr[%s], say hi.\n", *s) //取地址中的值,需要星花符"*"
}

func main() {
//定义接口类型的变量
var i Humaner //i的类型是Humaner接口

//只要实现了此接口方法的类型,那么这个类型的变量(接收者类型)就可以赋值给接口的变量
s := &Student{"Go", 1010} //接收者是指针类型,需要取出内存地址
i = s
i.sayhi()

t := &Teacher{"Google Inc.", "Go"}
i = t
i.sayhi()

//把接口类型赋值给自定义类型
var str MyStr = "hello go" //需要显示写上MyStr类型,没有写,就会默认推导成字符串类型。字符串类型和MyStr类型,不是同一个类型
i = &str
i.sayhi()
}

/*
运行结果:
Student[Go, 1010], say hi.
Teacher[Google Inc., Go], say hi.
MyStr[hello go], say hi.
*/

同一个接口实现了不同的表现,就看给接口类型的变量,赋值了一个什么类型。
大致流程分析:
首先:声明了一个接口类型,这个接口类型中有一个叫 sayhi() 的方法。接口类型只有方法的声明,没有方法的实现以及其他任何属性、变量
接下来:每一个结构体都实现了该方法。以 func (s *Student) sayhi() {...} 为例,sayhi 中实现了一些行为(说白了就是写了些代码,要 *Student 这个类型干些什么事情),并绑定到了 *Student 类型中。
紧接着:定义了一个接口变量 i,&Student 赋值给了 i(因为 Student 的接收者类型是一个指针类型,所以需要传递一个内存地址给它)。调用 i.sayhi() 的时候,就会去找 &Student 中的那个 sayhi() 方法。
同理:Teacher 的地址重新赋值给了 i,再次调用 i.sayhi() 的时候,就会去找 &Teacher 中的那个 sayhi() 方法。
最后:自定义类型 MyStr 的变量 &str 赋值给了i,调用的时候就会去找 &MyStr 中的那个 sayhi() 方法。注意:MyStr 一定要显示写法,不写的话,str 就会被自动推导成为 string 类型。string 类和 MyStr 类型,根本不是同一个数据类型,肯定会报错!
总结:就看给接口变量赋值了什么类型的变量,根据赋值的变量类型,自动选择赋值变量类型所匹配的方法。

4.3 调用同一个函数,实现不同行为

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
//定义接口类型
type Humaner interface {
//方法的声明,没有实现,由别的类型(自定义类型)实现
sayhi()
}

type Student struct {
name string
stuNo int
}

//Student类型实现了sayhi()方法
func (s *Student) sayhi() {
fmt.Printf("Student[%s, %d], say hi.\n", s.name, s.stuNo)
}

type Teacher struct {
address string
group string
}

//Teacher类型实现了sayhi()方法
func (t *Teacher) sayhi() {
fmt.Printf("Teacher[%s, %s], say hi.\n", t.address, t.group)
}

type MyStr string

func (s *MyStr) sayhi() {
fmt.Printf("MyStr[%s], say hi.\n", *s)
}

//定义一个函数,接收接口类型的参数,一种接口实现多种行为
//参数接收一个实现了Humaner接口类型中sayhi()方法的变量
func WhoSayHi(i Humaner) {
i.sayhi()
}

func main() {
s := &Student{"Go", 1010}
t := &Teacher{"Google Inc.", "Go"}
var str MyStr = "hello go" //需要显示写上MyStr类型,没有写,就会默认推导成字符串类型。string类型和MyStr类型,不是同一个类型

//下面3次调用同一个函数,但实现了不同的表现行为
WhoSayHi(s) //WhoSayHi的参数是一个普通接口类型,但结构体接收者的类型是*Student,所以s的类型需要是一个指针类型(内存地址)
WhoSayHi(t)
WhoSayHi(&str)

fmt.Println("-----------------------------")

//创建一个切片,数据类型是Humaner接口类型
//此例中的变量只有3个,长度千万不要超了,不然第4个开始,就是空指针了,会报错!除非再另外赋值新的变量并加入到切片中
hs := make([]Humaner, 3)
hs[0] = s
hs[1] = t
hs[2] = &str

for _, i := range hs {
//每个i都是实现了Humaner接口类型的结构体变量
WhoSayHi(i) //两者写法等价
i.sayhi() //两者写法等价
}
}

/*
运行结果:
Student[Go, 1010], say hi.
Teacher[Google Inc., Go], say hi.
MyStr[hello go], say hi.
-----------------------------
Student[Go, 1010], say hi.
Student[Go, 1010], say hi.
Teacher[Google Inc., Go], say hi.
Teacher[Google Inc., Go], say hi.
MyStr[hello go], say hi.
MyStr[hello go], say hi.
*/

简单理解:func WhoSayHi(i Humaner) { i.sayhi() }这段代码中,i Humaner 不需要关心传过来的变量类型是什么,它只看那个变量有没有实现了 sayhi() 方法。只要传过来的变量中实现了 sayhi() 方法,那么Golang就会自行去查找该变量中的函数。如果该变量中没有实现 sayhi() 方法,让 Golang 怎么能找得到?

4.4 接口组合

接口组合的两种表现形式:接口嵌入、接口转换。

4.4.1 接口嵌入

如果一个 interface1 作为 interface2 的一个嵌入字段,那么 interface2 隐式地包含了 interface1 里面的所有方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
type Humaner interface {
sayhi()
}

type Songster interface {
Humaner //引用了Humaner这个接口,同时也包含了Humaner接口中的方法
sing(lrc string)
}

type Student struct {
name string
stuNo int
}

//Student实现Humaner中的sayhi()方法
func (s *Student) sayhi() {
fmt.Printf("Student[%s, %d], sayhi.\n", s.name, s.stuNo)
}

//Student同时也实现了sing()这个方法,定义时有参数,实现的时候也必须对应带上参数
func (s *Student) sing(lrc string) {
fmt.Printf("Student %s, is sing: %s\n", s.name, lrc)
}

func main() {
var i Songster //声明一个接口类型的变量

//结构体的接收者是个指针类型,所以需要给它一个内存地址
s := &Student{"xxxyyy", 999}
i = s

i.sayhi() //Songster接口嵌入了Humaner接口,Humaner接口中有sayhi()方法,那么Songster接口也会有这个方法
i.sing("god is a girl") //Songster接口自己独有的方法
}

/*
运行结果:
Student[xxxyyy, 999], sayhi.
Student xxxyyy, is sing: god is a girl
*/

Songster 接口中嵌入了 Humaner 接口,那么 Songster 就会得到 Humaner 接口中的所有方法。只需要实现 Songster 接口中的方法即可!
还有一个更加简洁的写法,修改上述 main() 中的代码成如下:

1
2
3
4
5
6
7
func main() {
//结构体的接收者是个指针类型,所以需要给它一个内存地址
s := &Student{"xxxyyy", 999}

s.sayhi() //Songster接口嵌入了Humaner接口,Humaner接口中有sayhi()方法,那么Songster接口也会有这个方法
s.sing("god is a girl") //Songster接口自己独有的方法
}

运行结果一模一样,大致流程:结构体 Student 已经实现了 sayhi() 和 sing(lrc string) 这两个方法,那么就绑定在了一起。只需要有这个结构体类型的变量,即可找到它已经实现的这两个方法。

4.4.2 接口转换

需要配合接口嵌入来使用。如果 interface2 嵌入了 interface1,那么 interface2 就可以转换给 interface1,因为 interface2 中即包含了它自己本身的方法也包含了 interface1 的方法;而 interface1 不能转换给 interface2,因为 interface1 没有嵌入 interface2,就没有 interface2 中的方法,所以不能转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
type Humaner interface {
sayhi()
}

type Songster interface {
Humaner //引用了Humaner这个接口,同时也包含了Humaner接口中的方法
sing(lrc string)
}

type Student struct {
name string
stuNo int
}

//Student实现Humaner中的sayhi()方法
func (s *Student) sayhi() {
fmt.Printf("Student[%s, %d], sayhi.\n", s.name, s.stuNo)
}

//Student同时也实现了sing()这个方法,定义时有参数,实现的时候也必须对应带上参数
func (s *Student) sing(lrc string) {
fmt.Printf("Student %s, is sing: %s\n", s.name, lrc)
}

func main() {
var i1 Humaner
var i2 Songster

i1 = i2
fmt.Println("i1=", i1)
}

/*
运行结果:
i1= <nil>
*/

上例中,Songster 接口嵌入了 Humaner 接口,所以 Songster 接口即有自己的方法又有 Humaner 的方法,Songster 可以转换给 Humaner;Humaner 没有 Songster 中的方法,所以不能把 Humaner 给 Songster 。
如果把 Songster 给了 Humaner,就会报错:

1
2
3
4
5
6
7
func main() {
var i1 Humaner
var i2 Songster

i2 = i1 //报错:Humaner does not implement Songster (missing sing method) ===> Humaner没有实现Songster,缺少sing方法
fmt.Println("i2=", i2)
}

可以用另外一种更加简洁的概念来理解:超集 子集超集就是方法数量多的那个接口,子集就是方法数量少的那个接口。超集可以给子集,子集不能给超集
详看下例代码的注释:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//子集:这个接口的方法数量少
type Humaner interface {
sayhi()
}

//超集:这个接口的方法数量多
type Songster interface {
Humaner //引用了Humaner这个接口,同时也包含了Humaner接口中的方法
sing(lrc string)
}

type Student struct {
name string
stuNo int
}

func (s *Student) sayhi() {
fmt.Printf("Student[%s, %d], sayhi.\n", s.name, s.stuNo)
}

func (s *Student) sing(lrc string) {
fmt.Printf("Student %s, is sing: %s\n", s.name, lrc)
}

func main() {
var i1 Humaner //子集
var i2 Songster //超集

//超集可以给子集
i1 = i2
fmt.Println("i1=", i1)
}

/*
运行结果:
i1= <nil>
*/

代码能编得过,没有问题。

4.5 空接口

空接口 interface({}) 不包含任何方法,可以接收任意类型。正因为如此,所有的类型都实现了空接口,空接口可以存储任意类型的数值。空接口就是个万能类型,能够保存任意类型的值

4.5.1 可以给空接口类型赋任意类型的值

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
type Any interface{} //any或Any,是空接口一个很好的别名或缩写

type Person struct {
name string
age int
}

func main() {
var any Any //空接口可以给任何值

any = 123
fmt.Printf("any type is: %T, value = %v\n", any, any)

any = "Golang"
fmt.Printf("any type is: %T, value = %v\n", any, any)

any = true
fmt.Printf("any type is: %T, value = %v\n", any, any)

any = Person{"Golang", 11}
fmt.Printf("any type is: %T, value = %v\n", any, any)

any = &Person{"Rob Pike", 55}
fmt.Printf("any type is: %T, value = %v\n", any, any)
}

/*
运行结果:
any type is: int, value = 123
any type is: string, value = Golang
any type is: bool, value = true
any type is: main.Person, value = {Golang 11}
any type is: *main.Person, value = &{Rob Pike 55}
*/

4.5.2 Print()系列函数的参数列表就是空接口类型

当函数可以接收任意类型的时候,我们会将其参数类型声明为:空接口 interface{} 类型。最经典的例子就是标准库 fmtPrint 系列的函数。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
var v1 interface{} = 1
var v2 interface{} = "Google"
var v3 interface{} = &v2
var v4 interface{} = struct{ X int }{1}
var v5 interface{} = &struct{ X int }{1}

fmt.Printf("v1=%v, v2=%v, v3=%v, v4=%v, v5=%v\n", v1, v2, v3, v4, v5)
}

/*
运行结果:
v1=1, v2=Google, v3=0xc0000341f0, v4={1}, v5=&{1}
*/

标准库 fmtPrintln() 函数的定义:func Println(a ...interface{}) (n int, err error),它的参数就是可以接收 0 个或多个的任意类型参数。

4.5.3 map[string]interface{} 演示

利用 interface{} 可以存放任意类型的值,这个特性。实现 map 多种数据类型的存储、读取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
func main() {
m := make(map[string]interface{})
m["int"] = 123
m["string"] = "hello"
m["bool"] = true
m["float64"] = 123.111
m["nil"] = nil
m["slice"] = []int{1, 2, 3}

m2 := make(map[string]int)
m2["aaa"] = 0

m["map"] = m2 // 在 map 中,嵌套另一个 map

for key, value := range m {
fmt.Printf("key=%s, value=%v\n", key, value)
}
}

/*
运行结果:
key=string, value=hello
key=bool, value=true
key=float64, value=123.111
key=nil, value=<nil>
key=slice, value=[1 2 3]
key=map, value=map[aaa:0]
key=int, value=123
*/

map 是无序的,所以每次打印结果的顺序都有可能不同。
参考文献:

https://github.com/fengchunjian/goexamples/blob/master/map_interface/null_interface.go
http://blog.ninja911.com/blog-show-blog_id-76.html

4.6 示例:使用 Sorter 接口排序

编写一个接口,实现对不同数据类型的冒泡排序。
要对一组数字或字符串排序,只需要实现三个方法:
1.反映元素个数的 Len() 方法。
2.比较第 i 和 j 个元素的 Less(i, j) 方法。
3.交换第 i 和 j 个元素的 Swap(i, j) 方法。

4.6.1 目录结构

XXX

4.6.2 编写接口的代码

编写一个接口,实现排序时,传过去的实参是这个接口类型。
./sort/sort.go 文件的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package sort

//声明接口,并声明需要实现的3个方法
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}

//实现冒泡排序的函数
func Sort(data Sorter) { //参数为接口类型
for pass := 1; pass < data.Len(); pass++ { //data.Len(),获取该类型的长度
for i := 0; i < data.Len()-pass; i++ {
//比较两个数值的大小
if data.Less(i+1, i) {
data.Swap(i, i+1) //实现交换
}
}
}
}

//检测是否已实现了排序
func IsSorted(data Sorter) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
}
return true
}

//声明IntArray变量为,切片类型存放int
type IntArray []int

//IntArray类型实现接口中的Len()方法,接收者为普通参数
func (p IntArray) Len() int {
return len(p)
}

//IntArray类型实现接口中的Less(i, j int)bool方法,接收者为普通参数
func (p IntArray) Less(i, j int) bool {
return p[i] < p[j]
}

//IntArray类型实现接口中的Swap(i, j int)方法,接收者为普通参数
func (p IntArray) Swap(i, j int) {
p[i], p[j] = p[j], p[i]
}

//定义StringArray变量为,切片类型存放字符串
type StringArray []string

func (p StringArray) Len() int {
return len(p)
}

func (p StringArray) Less(i, j int) bool {
return p[i] < p[j]
}

func (p StringArray) Swap(i, j int) {
p[i], p[j] = p[j], p[i]
}

//对一个int切片进行排序
func SortInts(a []int) {
Sort(IntArray(a)) //将a转换为IntArray类型
}

//对一个string切片进行排序
func SortStrings(a []string) {
Sort(StringArray(a)) //将a转换为StringArray类型
}

func IntsAreSorted(a []int) bool {
return IsSorted(IntArray(a))
}

func StringsAreSorted(a []string) bool {
return IsSorted(StringArray(a))
}

4.6.3 实现:不同数据类型调用同一个接口,完成排序

./main.go 文件的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package main

import (
"fmt"
"gitee.com/quanquan616/mySorter/sort"
)

func ints() {
//初始化一个切片,里面存放int值
data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
//将这个切片类型,转换为IntArray类型
a := sort.IntArray(data)
//因为IntArray类型已经实现了Sorter接口中的所有方法
//经过上一步的转换,此时a已经是IntArray类型,所以它与Sorter接口类型吻合
sort.Sort(a)

if !sort.IsSorted(a) {
panic("failed.")
}

fmt.Printf("The sorted array is: %v\n", a)
}

func strings() {
//初始化一个切片,存放string值
data := []string{"barry", "quanquan616", "Rita", "rita", "Barry", "sally", "Golang", "Sally"}
//将切片转换成StringArray类型
a := sort.StringArray(data)
//StringArray类型也已经实现了Sorter接口的所有方法
//所以a的类型可以被Sorter接口类型所接收
sort.Sort(a)

if !sort.IsSorted(a) {
panic("failed.")
}

fmt.Printf("The sorted array is: %v\n", a)
}

//根据结构体day中的num进行排序
type day struct {
num int
shortName string
longName string
}

type dayArray struct {
data []*day //声明data字段的类型为切片,存放day的指针变量
}

//dayArray类型实现Len()方法,接收者为指针类型
func (p *dayArray) Len() int {
//p是一个结构体类型,里面有一个data字段,data字段是一个切片类型
//p.data操作是取出那个一整个切片
return len(p.data)
}

func (p *dayArray) Less(i, j int) bool { //接收者为指针类型
//p.data操作得到了一个切片,既然是切片类型就能使用索引进行取值
return p.data[i].num < p.data[j].num
}

func (p *dayArray) Swap(i, j int) { //接收者为指针类型
p.data[i], p.data[j] = p.data[j], p.data[i]
}

func days() {
Sunday := day{0, "SUN", "Sunday"}
Monday := day{1, "MON", "Monday"}
Tuesday := day{2, "TUE", "Tuesday"}
Wednesday := day{3, "WED", "Wednesday"}
Thursday := day{4, "THU", "Thursday"}
Friday := day{5, "FRI", "Friday"}
Saturday := day{6, "SAT", "Saturday"}

//初始化一个切片,存放day的指针变量
//结构体dayArray类型中的data字段的类型为切片,切片中存放的数据类型为day的指针变量
data := []*day{&Tuesday, &Thursday, &Wednesday, &Sunday, &Monday, &Friday, &Saturday}
a := dayArray{data} //dayArray的数据类型是一个结构体,结构体的语法是大括号"{}"写法
sort.Sort(&a) //接收者是指针类型,需要一个合法指向。所以必须取地址,把地址的值传过去

if !sort.IsSorted(&a) {
panic("days sort failed.")
}

for _, d := range data {
fmt.Printf("%s ", d.longName)
}
fmt.Println()
}

func main() {
ints()
strings()
days()
}

4.6.4 最终运行结果

1
2
3
4
运行结果:
The sorted array is: [-5467984 -784 0 0 42 59 74 238 905 959 7586 7586 9845]
The sorted array is: [Barry Golang Rita Sally barry quanquan616 rita sally]
Sunday Monday Tuesday Wednesday Thursday Friday Saturday

4.6.5 不将 dayArray 声明为结构体的写法

4.6.3 的代码中,dayArray 是一个结构体类型,里面包含了一个 data 字段,字段类型为一个切片,存放的数据类型是 day 的指针变量。
如果不想使用结构体的话,可以如下写法:(其余代码不改动)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
type day struct {
num int
shortName string
longName string
}

//类型为一个切片,存放的数据类型为day的指针变量
type dayArray []*day

func (p *dayArray) Len() int {
//dayArray是一个切片了
return len(*p) //接收者是指针类型,因为指针类型存放的是内存地址的值,必须先取出值,才能进行计算
}

func (p *dayArray) Less(i, j int) bool {
//接收者是指针类型,需要先用星花*运算符取出地址中的值,才能有后续的操作
return (*p)[i].num < (*p)[j].num //(*p)操作是取出内存地址中的那个一个整个切片
}

func (p *dayArray) Swap(i, j int) {
(*p)[i], (*p)[j] = (*p)[j], (*p)[i]
}

func days() {
Sunday := day{0, "SUN", "Sunday"}
Monday := day{1, "MON", "Monday"}
Tuesday := day{2, "TUE", "Tuesday"}
Wednesday := day{3, "WED", "Wednesday"}
Thursday := day{4, "THU", "Thursday"}
Friday := day{5, "FRI", "Friday"}
Saturday := day{6, "SAT", "Saturday"}

data := []*day{&Tuesday, &Thursday, &Wednesday, &Sunday, &Monday, &Friday, &Saturday}
//dayArray是一个存放day指针变量的切片了
a := dayArray(data)
//接收者是指针类型,所以必须传址
sort.Sort(&a)

if !sort.IsSorted(&a) {
panic("days sort failed.")
}

for _, d := range data {
fmt.Printf("%s ", d.longName)
}
fmt.Println()
}

func main() {
days()
}

/*
运行结果:
Sunday Monday Tuesday Wednesday Thursday Friday Saturday
*/

可以看到,运行结果一模一样。
4.6.3 代码中的写法是将切片再次封装成为一个数据类型,通过操作该数据类型中的字段,得到一整个切片,然后再根据下标进行取值。
本例中的写法是声明一个变量,类型为存放指针变量的切片,每次都是直接操作这个变量。

4.6.6 参考文献

本节内容均来源于:
原文作者:Go 技术论坛文档:《Go 入门指南()》
转自链接:https://learnku.com/docs/the-way-to-go/the-first-example-of-117-sorting-using-the-sorter-interface/3653
版权声明:翻译文档著作权归译者和 LearnKu 社区所有。转载请保留原文链接

4.7 反射包reflect

反射可以在运行时检查类型和变量,例如它的大小、方法。
变量的最基本信息是:类型和值。反射包的 Type 用来表示一个类型,反射包的 Value 为值提供了反射接口。

4.7.1 最基本的两个函数

reflect.TypeOf(),返回变量的类型。
reflect.ValueOf(),返回变量的值。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

```go

## 五、类型断言

类型查询也叫类型断言,常用的有两种方式:
1.comma-ok 断言(`if`)
2.type-switch 测试(`switch`)

### 5.1 if 实现类型断言

被判断的变量必须是一个接口变量,否则编译器会报错:`invalid type assertion: varI.(T) (non-interface type (type of varI) on left)` 。

#### 5.1.1 基本语法

`if value, ok := varName.(Type); ok == true {...}`。
`varName.(Type)` 采用`变量名.(数据类型)`的方式获取到:该变量的值和该变量是否为指定数据类型的 `bool` 值。

#### 5.1.2 最基本的使用

```go
if v, ok := varI.(T); ok {
Process(v)
return
}

如果断言成功(varI 是 T 类型),v 是 varI 本身的值,ok 会是布尔值 true。否则 v 是 T 类型的零值,ok 会是布尔值 false,不会造成运行时错误。
注意:varI 需要是一个接口变量。

5.1.3 简洁写法

多数情况下,可能只是想在 if 中测试一下 ok 的值,此时使用下面的写法会显得更加简洁、方便。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
if _, ok := varI.(T); ok {
//...
}
123
```go

#### 5.1.4 示例

```go
type Student struct {
name string
stuNo int
}

func main() {
//声明一个长度为3的切片,里面的元素都是空接口。空接口可以接收任意的数据类型
items := make([]interface{}, 3)

items[0] = 111
items[1] = "Golang"
items[2] = Student{"xxx", 999}

//遍历,第一个返回元素的下标,第二个返回数据值。这里就是返回接口中的值
for index, data := range items {

//data.(int)返回两个值,第一个是该变量本身的值,第二个返回该变量是否为指定数据类型的bool
if value, ok := data.(int); ok == true {
fmt.Printf("items[%d] type is int, value=%d\n", index, value)
} else if value, ok := data.(string); ok == true {
fmt.Printf("items[%d] type is string, value=%s\n", index, value)
} else if value, ok := data.(Student); ok == true { //data这个变量是否为Student类型,Student是自定义的结构体类型
fmt.Printf("items[%d] type is Student, value=%+v\n", index, value)
}
}
}

/*
运行结果:
items[0] type is int, value=111
items[1] type is string, value=Golang
items[2] type is Student, value={name:xxx stuNo:999}
*/

5.2 type-switch

在程序运行时的时候进行类型分析。在处理来自于外部的、类型未知的数据时,比如解析诸如 JSON 或 XML 编码的数据,类型测试和转换会非常有用。

5.2.1 基本写法

1
2
3
4
5
6
switch t := data.(type) {
case type:
...
case type:
...
}

注意:
1.switch t := data.(type) 这条语句中,type 是关键字的那个type,不要写明数据类型。变量 t 在内存中占据两个字长:一个是其本身的类型,还有一个是其本身的值。
2.case type 语句中的 type 是写明具体的一个数据类型(例如:int, string, StructName),case type 根据 switch 语句中的 t 会去自行匹配。
3.data.(type) 必须在 switch 中使用,否则就报错

5.2.2 简洁写法

如果仅仅只是测试变量的类型,不想用它的值,那么就可以不需要赋值语句。
示例:

1
2
3
4
5
6
7
8
switch areaIntf.(type) {
case *Square:
//...
case *Circle:
//...
default:
//...
}

5.2.3 示例1:基本示例

将所有值放入一个切片中,切片的数据类型是空接口。(空接口是万能类型,允许接收任意类型)
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
type Student struct {
name string
stuNo int
}

func main() {
//声明一个长度为4的切片,里面的元素都是空接口。空接口可以接收任意的数据类型
items := make([]interface{}, 4)

items[0] = 111
items[1] = "Golang"
items[2] = Student{"xxx", 999}
items[3] = false

//遍历,第一个返回元素的下标,第二个返回数据值。这里就是返回接口中的值
for index, data := range items {
switch data.(type) { //type是关键字,会自行跟下面各个case去匹配
case int:
fmt.Printf("items[%d] type is int, value=%d\n", index, data)
case string:
fmt.Printf("items[%d] type is string, value=%s\n", index, data)
case Student:
fmt.Printf("items[%d] type is Student, value=%+v\n", index, data)
case bool:
fmt.Printf("items[%d] type is bool, value=%v\n", index, data)
}
}
}

/*
运行结果:
items[0] type is int, value=111
items[1] type is string, value=Golang
items[2] type is Student, value={name:xxx stuNo:999}
items[3] type is bool, value=false
*/

5.2.4 示例2:判定每个值的类型

给定一些值,根据每个值的实际类型执行不同的动作。
示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
func classifier(params ...interface{}) {
for _, item := range params {
switch t := item.(type) {
case int, int16, int32, int64:
fmt.Printf("%v is an int type.\n", t)
case bool:
fmt.Printf("%v is a bool type.\n", t)
case float32, float64:
fmt.Printf("%v is a float.\n", t)
case string:
fmt.Printf("%v is a string.\n", t)
case nil:
fmt.Printf("it's a nil.\n")
default:
fmt.Println("%v is unknow.\n", t)
}
}
}

func main() {
classifier(13, -14.3, "BELGIUM", complex(1, 2), nil, false)
}

/*
运行结果:
13 is an int type.
-14.3 is a float.
BELGIUM is a string.
%v is unknow.
(1+2i)
it's a nil.
false is a bool type.
*/

5.2.5 示例3:type-switch 配合匿名函数

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
type specialString string //声明一个自定义类型,其底层类型为string

var whatItThis specialString = "Hello Golang." //自定义类型的底层类型为string,因此可以把字符串复制给它

func TypeSwitch() {
testFunc := func(any interface{}) { //匿名函数的参数是空接口(万能接口),可以接收任何值
switch v := any.(type) { //v包含两个字长:一个是类型,另一个是本身的值
case bool:
fmt.Printf("v type is bool, value = %v\n", v)
case int:
fmt.Printf("v type is int, value = %v\n", v)
case float32, float64:
fmt.Printf("v type is float, value = %v\n", v)
case string:
fmt.Printf("v type is string, value = %v\n", v)
case specialString:
fmt.Printf("v type is a customize type: specialString, value = %v\n", v)
default:
fmt.Println("v type is unkonw")
}
}
testFunc(whatItThis)
}

func main() {
TypeSwitch()
}

/*
运行结果:
v type is a customize type: specialString, value = Hello Golang.
*/

本例的参考文献:

https://learnku.com/docs/the-way-to-go/119-empty-interface/3655

5.2.6 注意事项

5.2.6.1 case 语句中列举的类型,都必须实现对应的接口

所有 case 语句中列举的类型(nil 除外)都必须实现对应的接口。如果被检测类型没有在 case 语句列举的类型中,就会执行 default 语句。

5.2.6.2 在 type-switch 不允许有 fallthrough

可以用 type-switch 进行运行时类型分析,但是在 type-switch 不允许有 fallthrough。