目录概述基本使用Java中的interface（接口）go中的interface（接口）gointerface的优势空接口如何使用interface{}类型的参数？类型断言另外一种类型...

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

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

概述

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

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

typeFlyableinterface{
Fly()string
}

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

varaFlyable

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

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

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

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


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


基本使用

Java 中的 interface（接口）

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

interface
//定义一个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);
}
}

FlyableFlyableBirdflyFlyableBirdFlyablebfly
interfaceimplements
implements

go 中的 interface（接口）

interfaceimplementsinterfaceinterface
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)
}

PersonStringerStringerPerson
implements

Golang中interface的基本用法详解

go interface 的优势

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

codersay_hello
defhello_world(coder):
coder.say_hello()

hello_worldsay
typesayinterface{
say_hello()
}

funchello_world(codersay){
coder.say_hello()
}

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

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

空接口

interface{}anyinterface{}interface{}
fmtprintln

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

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

类型断言

interface{}
funcfly(finterface{}){
//第一个返回值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)fFlyablef.(Bird)fBird

另外一种类型断言方式

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

fFlyableFly
fFlyablepanicv, 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."
}

BirdFlyFlyableBird

一种简单的解决方法

BirdFlyable
var_Flyable=Bird{}

BirdFlyableBirdFlyableBirdFlyable

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

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

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
}

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

funcbar(cCloser){
c.Close()
}

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

Golang中interface的基本用法详解

接口与 nil 不相等

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

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

interface{}typedatanilnilinterface{}nilnilinterface{}typedatanilnil

Golang中interface的基本用法详解

嵌套的接口

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

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

typeCloserinterface{
Close()error
}

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

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

myFileWriterCloserWriteClosermyFileWriteCloserWriterCloser

Golang中interface的基本用法详解

总结

接口里面只声明了方法，没有数据成员。
go 中的接口不需要显式声明（也不能）。
只要一个类型实现了接口的所有方法，那么该类型实现了此接口。该类型的值可以赋值给该接口类型。
interface{}any

interface{}

_

一个类型可以同时实现多个接口，可以当作多个接口类型来使用。
nilnilinterface{}

go 中的接口可以嵌套，类似结构体的嵌套。