Go的第11课——接口

接口

基本用法

接口像是一个公司里面的领导，他会定义一些通用规范，只设计规范，而不实现规范。

go 语言的接口，是一种新的类型定义，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

语法格式和方法非常类似。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*定义接口*/
type interface_name interface {
    method_name1[return_type]
    method_name2[return_type]
    method_name3[return_type]
    ...
    method_namen[return_type]
}
/*定义结构体*/
type struct_name struct{
    /*variables*/
}
/*实现接口方法*/
func（struct_name_variable struct_name）method_name1（）[return_type]{
    /*方法实现*/
}
func（struct_name_variable struct_name）method_namen（）[return_type]{
    /*方法实现*/
}

实例演示

这里我定义一个 USB 接口，来让电脑和手机都实现，这里其实已经比较像面向对象了。

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
package main

import "fmt"

type USB interface {
    Read()
    Write()
}
type Computer struct {
    buffer string
}

type Phone struct {
    buffer string
}

func (c Computer) Read() {
    fmt.Println("computer read")
}

func (c Computer) Write() {
    fmt.Println("computer write")
}
func (p Phone) Read() {
    fmt.Println("Phone read")
}
func (p Phone) Write() {
    fmt.Println("Phone write")
}

func main() {
    var c Computer
    c.Read()
    c.Write()
    var p Phone
    p.Read()
    p.Write()
}
/*
computer read
computer write
Phone read    
Phone write   
*/

这个接口的定义跟 java 那边是差不多的，然后再结合一下 go 的方法定义就能很快写出来了。

然后就是感觉这个接口有点空谈了，因为我没有办法强制一个结构体去实现某个方法，也可能是我还不知道怎么去实现，如果做不到那一点的话感觉接口就是空谈吧。

弹幕有人说多态下面会有些问题，那就再看吧，先 mark 一下，后面看到多态了再回来补。

终于是知道了，它 interface 可以是一个变量类型，可以声明这个类型的指针而去 new 一个实现了它接口的结构体。这就是所谓的多态了，然后呢如果我没有完全实现它所有的接口里面的方法，那么这个 new 就会出问题，比如我删除了 write 的代码，尝试去 new Phone 的时候，编译器报错

至于多态写法，就可以康康这个例子

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
package main

import "fmt"

type USB interface {
    Read()
    Write()
}
type Computer struct {
    buffer string
}

type Phone struct {
    buffer string
}

func (c Computer) Read() {
    fmt.Println("computer read")
}

func (c Computer) Write() {
    fmt.Println("computer write")
}
func (p Phone) Read() {
    fmt.Println("Phone read")
}

func (p Phone) Write() {
    fmt.Println("Phone write")
}

func main() {
    var c Computer
    //c.Read()
    //c.Write()
    var p Phone
    //p.Read()
    //p.Write()
    var ptr USB = new(Phone)
    ptr = &p
    ptr.Read()
    ptr = &c
    ptr.Read()
}
/*
Phone read
computer read
*/

接口嵌套

我可以通过其它已有的接口组合来创建新的接口，写法如下：

1
2
3
4
5
type identifier interface{
    interface1
    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
37
package main

import "fmt"

type Cat interface {
    climb()
}
type Bear interface {
    run()
}
type Panda interface {
    Cat
    Bear
}
type PANDA struct {
    name string
}

func (p PANDA) run() {
    fmt.Printf("%s run\n", p.name)
}
func (p PANDA) climb() {
    fmt.Printf("%s climb\n", p.name)
}

func main() {
    var p Panda
    var b PANDA
    b.name = "www"
    p = &b
    p.run()
    p.climb()
}
/*
www run
www climb
*/