golang 中的接口和别的面向对象中的接口有很大的不同。

接口的定义

1
2
3
4
//定义一个接口,它有一个run 方法
type Runable interface {
	run()
}

定义一个Runable 接口,它有一个方法,run() , 这个方法没有参数也没有返回值

结构体可以定义一个方法,如果某个结构体定义了run() 方法,则说明该结构体实现了 Runable 接口,并不像java 或者 python 中的类,在定义的时候在显示的说明继承自哪个接口。

接口可以有值

这个和大多数的面向对象语言有区别,它们的接口是不可以实例化的,但是Go中的接口是可以"实例"的

1
2
3
4
func main() {
	var r Runable
	fmt.Println(r)
}

打印出来是nil, 也就是说,实例化接口得到的是一个空指针,空指针此时是不能直接调用接口方法的,如 r.run(),

之后如果想要将该指针赋值,也要指向一个实现了run() 方法的结构体变量

如果指向了实例,则可以调用run方法。

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

import "fmt"

//定义一个接口,它有一个run 方法
type Runable interface {
	run()
}

type Person struct {
	name string
	age int
}

type Cat struct {
	name string
}

//实现了Runable接口的run方法
func (self *Person) run() {
	fmt.Println("Person run....")
}

func main() {
	var r Runable
	fmt.Println(r)
    // 这里会编译错误
    //r.run() 
	p := Person{"yyx", 18}
	c := Cat{"mimi"}
	r = &p
	//r = c
    r.run()  // 这里会调用Person的run方法
}

上面代码在 r = c 时会出现编译错误

1
Cannot use 'c' (type Cat) as the type Runable Type does not implement 'Runable' as some methods are missing: run()

意思就是 Cat 类并没有实现 Runable 接口的 run() 方法

通过接口实现多态

多态在面向对象语言中非常重要,由于有了多态,才会发挥面向对象的优势,我们在定义一个函数时,参数可以使用接口类型,在真正调用该函数的时候,只要传入一个实现了该接口的结构体即可。

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

import "fmt"

//定义一个接口,它有一个run 方法
type Runable interface {
	run()
}

type Person struct {
	name string
	age int
}

type Dog struct {
	name string
}

func (self *Person) run() {
	fmt.Println("Person run....")
}

func (self Dog) run() {
	fmt.Println("Dog run....")
}

// 定义一个test函数,参数为Runable 接口类型
func test(obj Runable)  {
	obj.run()
}

func main() {
	p := Person{"yyx", 18}
	d := Dog{"wangwang"}
	// 将实现了Runable 接口的结构体用为参数,当调用相应的方法
	test(&p)
	test(d)

}

上面代码输出为

Person run....
Dog run....

上面代码中定义了一个test(obj Runable) 函数,参数为Runable 接口,在之后的调用中,只要传一个实现了Runable接口的结构体即可, test函数中调用了run() 方法,将会调用结构体相应的run方法。

结构体方法的接收者类型

结构体在实现接口方法的时候,接收者参数可以是值类型也可以是指针类型,这个是之后的调用过程中是有影响的

在上面的代码中

1
2
3
4
5
6
7
func (self *Person) run() {
	fmt.Println("Person run....")
}

func (self Dog) run() {
	fmt.Println("Dog run....")
}

Person 使用的是指针类型,Dog 使用的是值类型,

那么在之后的test() 函数调用时

1
2
3
4
5
6
p := Person{"yyx", 18}
d := Dog{"wangwang"}
// 将实现了Runable 接口的结构体用为参数,当调用相应的方法
test(&p)
test(d)

Person 类型的就要传地址,Dog 类型的就可以直接传值。

另外,对于接口值也需要注意

1
2
3
4
5
6
var r Runable
fmt.Println(r)
p := Person{"yyx", 18}
d := Dog{"wangwang"}
r = &p
r = d

r 在刚初始化的时候是nil, 如果实现方法接收者为指针类型,那么r也要指向结构体变量地址,如接收者为值类型,那么r 可以直接指向结构体变量。

接口变量的类型判断

如上面的代码定义,有一个Runable 接口,有两个结构体,Person 和 Dog , 如果某个时刻你想知道这个接口变量到底是哪个结构体时,可以使用接口变量类型判断

  1. 使用 v := varI.(T) 形式
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
func main() {
	var r Runable
	p := Person{"yyx", 18}
	d := Dog{"wangwang"}
	r = d
	dd := r.(Dog)
	fmt.Println(dd, "ddd")
	pp := r.(*Person)
	fmt.Println(pp, "pp")
}

如果接口变量是T类型的话,则返回的v就是接口所指向的变量,如果不是T类型的话,则发生panic

上面的结果为

1
2
3
{wangwang} ddd
panic: interface conversion: main.Runable is main.Dog, not *main.Person

  1. 使用 if v, ok := varI.(T); ok 形式

上面的代码会导致panic, 更加安全的方式上使用if 判断的形式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func main() {
	var r Runable
	p := Person{"yyx", 18}
	d := Dog{"wangwang"}
	r = d
	if person, ok := r.(*Person); ok{
		fmt.Println(person, 222)
	}else {
		fmt.Println(person, 333)
	}
	if dog, ok := r.(Dog); ok{
		fmt.Println(dog, 444)
	}else{
		fmt.Println(dog, 555)
	}
}

由于将r指向了Dog的变量d,所以上面的代码输出为

1
2
<nil> 333
{wangwang} 444
  1. type-switch 形式
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func main() {
	var r Runable
	fmt.Println(r)
	p := Person{"yyx", 18}
	d := Dog{"wangwang"}
	r = d
	switch t:= r.(type) {
	case *Person:
		fmt.Printf("Type Person %T value %v \n", t,t)
	case Dog:
		fmt.Printf("Type Dog %T value %v \n", t,t)
	case nil:
		fmt.Println("t is nil....")
	default:
		fmt.Println("default case......")
	}
}

case 中除了nil 和default 之外的结构体都需要实现接口方法,否则编译错误。

判断值是否实现了某个接口

如果想要判断某个值是否实现了某个接口, 可以使用v.(Inter)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
func main() {
	var r Runable
	fmt.Println(r)
	p := Person{"yyx", 18}
	d := Dog{"wangwang"}
	// 判断某个值是否实现了Runable接口
	r = &p
	if _, ok := r.(Runable); ok{
		fmt.Println("p 实现了Runable接口")
	}else{
		fmt.Println("p 没有实现Runable接口")
	}
}

我的理解,这里的检查某个接口值是否实现了某个接口,相当于判断了该接口是否是nil, 当接口值想要指向某个变量时,如果那个变量没有实现接口方法,也不可能指向成功。

上面的代码,如果将 r = &p 注释掉,则OK 为false,此时只能说明nil 刚初始化,指向的是nil.