Go语言 | Interface

发表于 | 分类于 | | 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//1
type I interface {    
    Get() int
    Set(int)
}
//2
type S struct {
    Age int
}
func(s S) Get()int {
    return s.Age
}
func(s *S) Set(age int) {
    s.Age = age
}
//3
func f(i I){
    i.Set(10)
    fmt.Println(i.Get())
}
func main() {
    s := S{} 
    f(&s)  //4
}

这段代码在 #1 定义了 interface I，在 #2 用 struct S 实现了 I 定义的两个方法，接着在 #3 定义了一个函数 f 参数类型是 I，S 实现了 I 的两个方法就说 S 是 I 的实现者，执行 f(&s) 就完了一次 interface 类型的使用。

Go语言中，只要是实现了接口中定义的所有方法，就实现了该接口。也就可以调用接口类型的函数。

也就是实现了鸭子类型。在鸭子类型中，关注点在于对象的行为，能作什么；而不是关注对象所属的类型。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为”鸭子”的对象，并调用它的”走”和”叫”方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的”走”和”叫”方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的”走”和”叫”方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

（如野鸭会叫，机器鸭也会叫，叫法不一样，但都可以调用叫的方法）

如下代码通过interface实现了基于类型的多态实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}

func main() {
	do(21)
	do("hello")
	do(true)
}