1. 通过Implements方法

1.1 方法定义

Implements是Type接口类型的一个方法，专门用来判断某类型是否实现了指定接口，定义如下：

type Type interface {
	...
	// Implements reports whether the type implements the interface type u.
	Implements(u Type) bool
	...
}
1
2
3
4
5
6

1.2 实践

dog结构体实现了animal接口，最终返回值为true

package main

import (
	"fmt"
	"reflect"
)

type dog struct {
}
type animal interface {
	speak()
}

func (a *dog) speak() {
	fmt.Println("wang wang wang!")
}

func main() {
	typ_dog := reflect.TypeOf(&dog{})
	typ_animal := reflect.TypeOf((*animal)(nil)).Elem()
	fmt.Println(typ_dog.Implements(typ_animal))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 通过赋值/传参的方式

这种方式相对比较low，一般编译时直接报错（或者IDE直接就给错误提示了），会导致程序无法运行
看下面一个例子，dog结构体实现了animal接口，最终成功输出success

package main

import (
	"fmt"
)

type dog struct {
}
type animal interface {
	speak()
}

func (a *dog) speak() {
	fmt.Println("wang wang wang!")
}

func test(a animal) {
	fmt.Println("success")
}

func main() {
	test(&dog{})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

如果dog结构体没有实现animal接口，main函数中的test()就会报错

ps:
类似的判断方法还有

• var _ animal = (*dog)(nil)
• var _ animal = &dog{}

3. 通过断言的方式

通过断言方式接口.(类型)也可以判断某一类型是否实现指定接口（也会编译时报错），看下面的例子，最终会输出success

package main

import (
	"fmt"
)

type dog struct {
}
type animal interface {
	speak()
}

func (a *dog) speak() {
	fmt.Println("wang wang wang!")
}

func test(a animal) {
	if _, ok := a.(*dog); ok {
		fmt.Println("success")
	}
}

func main() {
	test(&dog{})
}
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

下图是没有实现接口时的报错

ps: 类似的断言方法还有(下面一串代码a的值为nil，ok为false)

func main() {
	var a animal
	if _, ok := a.(*dog); ok {
		fmt.Println(ok)
	}
}
1
2
3
4
5
6

注：使用断言时，如果接口类型的值为nil，使用if _, ok := 接口.(类型)，其ok值为false