Go语言仅支持封装,不支持继承和多态;没有类class,用结构体struct,主要是函数式编程和面向接口编程
一、方法
Go中方法就是一类带特殊的 接收者 参数的函数。方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。
可将方法理解为是个带接收者参数的函数。
func (接收者) 方法名称(参数) 放回值 {方法体}
值接收者和指针接收者
要改变接收者是的时候必须使用指针接收者
结构过大也考虑使用指针接收者(性能、内存)
一致性：如果有指针接收者，最好都使用指正接收者
值接收者是Go特有特性。用于逻辑运算场景，不改变接收者的值
通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用
值接收者1
2
3func (node treeNode) print() {
fmt.Println(node.value)
}
指针接收者1
2
3func (node *treeNode) setValue(value int) {
node.value = value
}
通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用
示例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//定义一个简单的二叉树结构体
type treeNode struct {
value int
leftNode,rightNode *treeNode
}
//结构体的方法 接收者为值
func (node treeNode) print() {
fmt.Println(node.value)
}
//设置是 接收者为指针
func (node *treeNode) setValue(value int) {
node.value = value
}
//遍历二叉树
func (node *treeNode) traverse() {
if nil == node {
return
}
node.print()
node.leftNode.traverse()
node.rightNode.traverse()
}
//结构体创建 工厂函数
func createNode(value int) *treeNode {
return &treeNode{value:value}
}
//结构体创建演示
func StructDemo() {
//创建结构体 方式一
//var root treeNode
//创建结构体 方式二
root := treeNode{value:-1}
//创建结构体 方式三
//root := new(treeNode)
//赋值
root.leftNode = &treeNode{value:1}
root.rightNode = &treeNode{value:2}
root.leftNode.leftNode = createNode(11)
root.leftNode.rightNode = createNode(12)
root.rightNode.leftNode = createNode(21)
root.rightNode.rightNode = createNode(22)
fmt.Println(root)
//调用结构体方法
root.setValue(0)
root.print()
fmt.Println("===== 二叉树遍历 ====")
root.traverse()
}
二、接口
接口类型 interface 是由一组方法签名定义的集合。接口类型的变量可以保存任何实现了这些方法的值。
类型通过实现一个接口的所有方法来实现该接口。不需要专门显式声明，所以就没有“implements”关键字;隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。
接口也是值,它们可以像其它值一样传递;接口值可以用作函数的参数或返回值。在内部，接口值可以看做包含值和具体类型的元组(value, type);接口值保存了一个具体底层类型的具体值。接口值调用方法时会执行其底层类型的同名方法。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//接口interface
type iPerson interface {
say() string
}
//结构体
type Person struct {
name string
}
//实现接口方法
func (p Person) say() string {
return p.name + " say hello!"
}
func describe(i iPerson) {
fmt.Printf("(%v, %T)\n", i, i)
}
func InterDemo() {
var i iPerson
ps := Person{name:"张三"}
i = ps
fmt.Println(i.say())
describe(i)//({张三}, mi.Person)
//隐式实现
var i2 iPerson = Person{name:"李四"}
fmt.Println(i2.say())
describe(i2)//({李四}, mi.Person)
}
空接口
指定了零个方法的接口值被称为 空接口,因为每个类型都至少实现了零个方法,所以空接口可保存任何类型的值；常被用来处理未知类型的值(例如: fmt.Print)
var i interface{}
类型断言
提供了访问接口值底层具体值的方式。
t := i.(T)
该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。若 i 并未保存 T 类型的值,则会panic
t, ok := i.(T)
若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true；否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生panic
类型选择
是一种按顺序从几个类型断言中选择分支的结构，类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类（而非值），它们针对给定接口值所存储的值的类型进行比较；类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。
switch v := i.(type) {
case T:
// v 的类型为 T
case S:
// v 的类型为 S
default:
// 没有匹配，v 与 i 的类型相同
}
1 | //类型选择 |