Golang中interface的基本用法详解

目录

• 概述
• 基本使用
• Java 中的 interface（接口）
• go 中的 interface（接口）
• go interface 的优势
• 空接口
• 如何使用 interface{} 类型的参数？
• 类型断言
• 另外一种类型断言方式
• switch...case 中判断接口类型
• 编译器自动检测类型是否实现接口
• 一种简单的解决方法
• 类型转换与接口断言
• 一个类型可以实现多个接口
• 接口与 nil 不相等
• 嵌套的接口
• 总结

Go 中接口也是一个使用得非常频繁的特性，好的软件设计往往离不开接口的使用，比如依赖倒置原则（通过抽象出接口，分离了具体实现与实际使用的耦合）。 今天，就让我们来了解一下 Go 中接口的一些基本用法。

概述

Go 中的接口跟我们常见的编程语言中的接口不太一样，go 里面实现接口是不需要使用 implements 关键字显式声明的， go 的接口为我们提供了难以置信的一系列的灵活性和抽象性。接口有两个特点：

• 接口本质是一种自定义类型。（跟 Java 中的接口不一样）
• 接口是一种特殊的自定义类型，其中没有数据成员，只有方法（也可以为空）。

go 中的接口定义方式如下：

typeFlyableinterface{
Fly()string
}

接口是完全抽象的，不能将其实例化。但是我们创建变量的时候可以将其类型声明为接口类型：

varaFlyable

然后，对于接口类型变量，我们可以把任何实现了接口所有方法的类型变量赋值给它，这个过程不需要显式声明。 例如，假如 Bird 实现了 Fly 方法，那么下面的赋值就是合法的：

//Bird实现了Flyable的所有方法
varaFlyable=Bird{}

go 实现接口不需要显式声明。

由此我们引出 go 接口的最重要的特性是：

• 只要某个类型实现了接口的所有方法，那么我们就说该类型实现了此接口。该类型的值可以赋给该接口的值。

• 因为 interface{} 没有任何方法，所以任何类型的值都可以赋值给它（类似 Java 中的 Object）

基本使用

Java 中的 interface（接口）

先看看其他语言中的 interface 是怎么使用的。

我们知道，很多编程语言里面都有 interface 这个关键字，表示的是接口，应该也用过，比如 Java 里面的：

//定义一个Flyable接口
interfaceFlyable{
publicvoidfly();
}

//定义一个名为Bird的类，显式实现了Flyable接口
classBirdimplementsFlyable{
publicvoidfly(){
System.out.println("Birdfly.");
}
}

classTest{
//fly方法接收一个实现了Flyable接口的类
publicstaticvoidfly(Flyableflyable){
flyable.fly();
}

publicstaticvoidmain(String[]args){
Birdb=newBird();
//b实现了Flyable接口，所以可以作为fly的参数
fly(b);
}
}

在这个例子中，我们定义了一个 Flyable 接口，然后定义了一个实现了 Flyable 接口的 Bird 类， 最后，定义了一个测试的类，这个类的 fly 方法接收一个 Flyable 接口类型的参数， 因为 Bird 类实现了 Flyable 接口，所以可以将 b 作为参数传递给 fly 方法。

这个例子就是 Java 中 interface 的典型用法，如果一个类要实现一个接口，我们必须显式地通过 implements 关键字来声明。 然后使用的时候，对于需要某一接口类型的参数的方法，我们可以传递实现了那个接口的对象进去。

Java 中类实现接口必须显式通过 implements 关键字声明。

go 中的 interface（接口）

go 里面也有 interface 这个关键字，但是 go 与其他语言不太一样。 go 里面结构体与接口之间不需要显式地通过 implements 关键字来声明的，在 go 中，只要一个结构体实现了 interface 的所有方法，我们就可以将这个结构体当做这个 interface 类型，比如下面这个例子：

packagemain

import"fmt"

//定义一个Flyable接口
typeFlyableinterface{
Fly()string
}

//Bird结构体没有显式声明实现了Flyable接口（没有implements关键字）
//但是Bird定义了Fly()方法，
//所以可以作为下面fly函数的参数使用。
typeBirdstruct{
}

func(bBird)Fly()string{
return"birdfly."
}

//只要实现了Flyable的所有方法，
//就可以作为output的参数。
funcfly(fFlyable){
fmt.Println(f.Fly())
}

funcmain(){
varb=Bird{}
//在go看来，b实现了Fly接口，
//因为Bird里面实现了Fly接口的所有方法。
fly(b)
}

在上面这个例子中，Person 结构体实现了 Stringer 接口的所有方法，所以在需要 Stringer 接口的地方，都可以用 Person 的实例作为参数。

Go 中结构体实现接口不用通过 implements 关键字fNkdzs声明。（实际上，Go 也没有这个关键字）

go interface 的优势

go 接口的这种实现方式，有点类似于动态类型的语言，比如 python，但是相比 Python，go 在编译期间就可以发现一些明显的错误。

比如像 Python 中下面这种代码，如果传递的 coder 没有 say_hello 方法，这种错误只有运行时才能发现：

defhello_world(coder):
coder.say_hello()

但如果是 go 的话，下面这种写法中，如果传递给 hello_world 没有实现 say 接口，那么编译的时候就会报错，无法通过编译：

typesayinterface{
say_hello()
}

funchello_world(codersay){
coder.say_hello()
}

编程客栈

因此，go 的这种接口实现方式有点像动态类型的语言，在一定程度上给了开发者自由，但是也在语言层面帮开发者做了类型检查。

go 中不必像静态类型语言那样，所有地方都明确写出类型，go 的编译器帮我们做了很多工作，让我们在写 go 代码的时候更加的轻松。 interface 也是，我们无需显式实现接口，只要我们的结构体实现了接口的所有类型，那么它就可以当做那个接口类型使用（duck typing）。

空接口

go 中的 interface{} 表示一个空接口（在比较新版本中也可以使用 any 关键字来代替 interface{}），这个接口没有任何方法。因此可以将任何变量赋值给 interface{} 类型的变量。

这在一些允许不同类型或者不确定类型参数的方法中用得比较广泛，比如 fmt 里面的 println 等方法。

如何使http://www.devze.com用 interface{} 类型的参数？

这个可能是大部分人所需要关心的地方，因为这可能在日常开发中经常需要用到。

类型断言

当实际开发中，我们接收到一个接口类型参数的时候，我们可能会知道它是几种可能的情况之一了，我们就可以使用类型断言来判断 interface{} 变量是否实现了某一个接口：

funcfly(finterface{}){
//第一个js返回值v是f转换为接口之前的值，
//ok为true表示f是Bird类型
ifv,ok:=f.(Flyable);ok{
fmt.Println("bird"+v.Fly())
}

//断言形式：接口.(类型)
if_,ok:=f.(Bird);ok{
fmt.Println("birdflying...")
}
}

在实际开发中，我们可以使用 xx.(Type) 这种形式来判断：

• interface{} 类型的变量是否是某一个类型
• interface{} 类型的变量是否实现了某一个接口

如，f.(Flyable) 就是判断 f 是否实现了 Flyable 接口，f.(Bird) 就是判断 f 是否是 Bird 类型。

另外一种类型断言方式

可能我们会觉得上面的那种 if 的判断方式有点繁琐，确实如此，但是如果我们不能保证 f 是某一类型的情况下，用上面这种判断方式是比较安全的。

还有另外一种判断方式，用在我们确切地知道 f 具体类型的情况：

funcfly2(finterface{}){
fmt.Println("bird"+f.(Flyable).Fly())
}

在这里，我们断言 f 是 Flyable 类型，然后调用了它的 Fly 方法。

这是一种不安全的调用，如果 f 实际上没有实现了 Flyable 接口，上面这行代码会引发 panic。 而相比之下，v, ok := f.(Flyable) 这种方式会返回第二个值让我们判断这个断言是否成立。

switch...case 中判断接口类型

除了上面的断言方式，还有另外一种判断 interface{} 类型的方法，那就是使用 switch...case 语句：

funcstr(finterface{})string{
//判断f的类型
switchf.(type){
caseint:
//f是int类型
return"int:"+strconv.Itoa(f.(int))
caseint64:
//f是int64类型
return"int64:"+strconv.FormatInt(f.(int64),10)
caseFlyable:
return"flyable..."
}
return"???"
}

编译器自动检测类型是否实现接口

上面我们说过了，在 go 里面，类型不用显式地声明实现了某个接口（也不能）。那么问题来了，我们开发的时候， 如果我们就是想让某一个类型实现某个接口的时候，但是漏实现了一个方法的话，IDE 是没有办法知道我们漏了的那个方法的：

typeFlyableinterface{
Fly()string
}

//没有实现Flyable接口，因为没有Fly()方法
typeBirdstruct{
}

func(bBird)Eat()string{
return"eat."
}

比如这段代码中，我们本意是要www.devze.com Bird 也实现 Fly 方法的，但是因为没有显式声明，所以 IDE 没有办法知道我们的意图。 这样一来，在实际运行的时候，那些我们需要 Flyable 的地方，如果我们传了 Bird 实例的话，就会报错了。

一种简单的解决方法

如果我们明确知道 Bird 将来是要当做 Flyable 参数使用的话，我们可以加一行声明：

var_Flyable=Bird{}

这样一来，因为我们有 Bird 转 Flyable 类型的操作，所以编译器就会去帮我们检查 Bird 是否实现了 Flyable 接口了。 如果 Bird 没有实现 Flyable 中的所有方法，那么编译的时候会报错，这样一来，这些错误就不用等到实际运行的时候才能发现了。

实际上，很多开源项目都能看到这种写法。看起来定义了一个空变量，但是实际上确可以帮我们进行类型检查。

这种解决方法还有另外一种写法如下：

var_Flyable=(*Bird)(nil)

类型转换与接口断言

我们知道了，接口断言可以获得一个具体类型（也可以是接口）的变量，同时我们也知道了，在 go 里面也有类型转换这东西， 实际上，接口断言与类型转换都是类型转换，它们的差别只是：

interface{} 只能通过类型断言来转换为某一种具体的类型，而一般的类型转换只是针对普通类型之间的转换。

//类型转换：f由float32转换为int
varffloat32=10.8
i:=int(f)

//接口的类型断言
varfinterface{}
v,ok:=f.(Flyable)

如果是 interface{}，需要使用类型断言转换为某一具体类型。

一个类型可以实现多个接口

上文我们说过了，只要一个类型实现了接口中的所有方法，那么那个类型就可以当作是那个接口来使用：

typeWriterinterface{
Write(p[]byte)(nint,errerror)
}

typeCloserinterface{
Close()error
}

typemyFilestruct{
}

//实现了Writer接口
func(mmyFile)Write(p[]byte)(nint,errerror){
return0,nil
}

//实现了Closer接口
func(mmyFile)Close()error{
returnnil
}

在上面这个例子中，myFile 实现了 Write 和 Close 方法，而这两个方法分别是 Writer 和 Closer 接口中的所有方法。 在这种情况下，myFile 的实例既可以作为 Writer 使用，也可以作为 Closer 使用：

funcfoo(wWriter){
w.Write([]byte("foo"))
}

funcbar(cCloser){
c.Close()
}

functest(){
m:=myFile{}
//m可以作为Writer接口使用
foo(m)
//m也可以作为Closer接口使用
bar(m)
}

接口与 nil 不相等

有时候我们会发现，明明传了一个 nil 给 interface{} 类型的参数，但在我们判断实参是否与 nil 相等的时候，却发现并不相等，如下面这个例子：

functest(iinterface{}){
fmt.Println(reflect.TypeOf(i))
fmt.Println(i==nil)
}

funcmain(){
varb*int=nil
test(b)//会输出：*intfalse
test(nil)//会输出：<nil>true
}

这是因为 go 里面的 interface{} 实际上是包含两部分的，一部分是 type，一部分是 data，如果我们传递的 nil 是某一个类型的 nil， 那么 interface{} 类型的参数实际上接收到的值会包含对应的类型。 但如果我们传递的 nil 就是一个普通的 nil，那么 interface{} 类型参数接开发者_JS学习收到的 type 和 data 都为 nil， 这个时候再与 nil 比较的时候才是相等的。

嵌套的接口

在 go 中，不仅结构体与结构体之间可以嵌套，接口与接口也可以通过嵌套创造出新的接口。

typeWriterinterface{
Write(p[]byte)(nint,errerror)
}

typeCloserinterface{
Close()error
}

//下面这个接口包含了Writer和Closer的所有方法
typeWriteCloserinterface{
Writer
Closer
}

WriteCloser 是一个包含了 Writer 和 Closer 两个接口所有方法的新接口，也就是说，WriteCloser 包含了 Write 和 Close 方法。

这样的好处是，可以将接口拆分为更小的粒度。比如，对于某些只需要 Close 方法的地方，我们就可以用 Closer 作为参数的类型， 即使参数也实现了 Write 方法，因为我们并不关心除了 Close 以外的其他方法：

funcfoo(cCloser){
//...
c.Close()
}

而对于上面的 myFile，因为同时实现了 Writer 接口和 Closer 接口，而 WriteCloser 包含了这两个接口， 所以实际上 myFile 可以当作 WriteCloser 或者 Writer 或 Closer 类型使用。

总结

• 接口里面只声明了方法，没有数据成员。
• go 中的接口不需要显式声明（也不能）。
• 只要一个类型实现了接口的所有方法，那么该类型实现了此接口。该类型的值可以赋值给该接口类型。
• interface{}/any 是空接口，任何类型的值都可以赋值给它。
• 通过类型断言我们可以将 interface{} 类型转换为具体的类型。
• 我们通过声明接口类型的 _ 变量来让编译器帮我们检查我们的类型是否实现了某一接口。
• 一个类型可以同时实现多个接口，可以当作多个接口类型来使用。
• nil 与值为 nil 的 interface{} 实际上不想等，需要注意。
• go 中的接口可以嵌套，类似结构体的嵌套。

以上就是golang中interface的基本用法详解的详细内容，更多关于Golang interface的资料请关注我们其它相关文章！