接口:方法对得上就能装进去

接口:方法对得上就能装进去
隔壁老康难度 ★☆☆☆☆ · 前置:结构体与方法:Go 的对象就这么回事 | 一句话结论:接口只声明自己需要哪些方法,任何类型只要把这些方法长齐,就能装进接口变量,一个字都不用声明。
我学 Go 的第三周接了个小活,要算几种图形的面积。当时我从 Java 那边带过来一个习惯,先写一个父类,让圆和方块都继承它,父类里留一个空方法等着子类覆盖。结果我在 Go 里找不到 extends,也找不到 abstract,翻文档翻了半天只看到 interface 这个词,可它长得又不像类。我把 Shape 写出来,看着里面两行只有签名没有函数体,心里犯嘀咕,这玩意儿真能装东西吗。后来在一个同事的代码里看到 var s Shape = Sq{3} 这一行,没有 new,没有 implements,也没有任何一句声明说 Sq 是个 Shape,它就这么进去了。那天我才反应过来,Go 的接口不是一份需要申报的户口,是一张用来核对的清单,方法对上了就打勾。更别扭的是,我一开始还想给 Sq 加一个标记,写上它属于哪个形状,找了半天没找到地方放。Go 里根本没有这样一个位置,类型定义那里只有字段,方法只能写在外面,没有任何一格留给归属关系。归属是编译器算出来的,不是人填的,所以也没有填错这回事。
对上就打勾,对不上就编不过。
接口写的是一张方法清单
定义接口用的是 type 加 interface,花括号里一行一个方法签名。Shape 里面就两行,左边是方法名和参数,右边是返回值,行尾没有花括号,也没有函数体。
1 | type Shape interface { |
这两行里没有一个字提到谁能实现它。接口不登记实现者,它只声明自己需要什么。谁想被当成 Shape 用,谁就得自己长出这两个方法,而且长出来的签名必须一模一样。
签名对上,才算对上。
名字差一个字母不算,参数多一个不算,返回值从 float64 换成 int 也不算。这类事情在别的地方顶多算个警告,在这里是硬邦邦的编译错误,一句解释都不给。好处是清单写在文件最上面,往下读代码的时候,只要扫一眼这个类型的方法列表,就知道它能不能对上,不用去别的地方查注册关系。维护老代码的时候这一点最省事,接口改了,对不上的地方一个都跑不掉,也不会漏掉某个角落里的实现。这套机制靠编译器一遍遍扫出来,不是靠人记住,所以它不会随时间烂掉。接口改一个方法名,全仓库里所有实现对不上的地方同时报错,改到一处不漏一处。要是在有 implements 关键字的地方,这种改动得靠查找引用顶着,漏了一处就等到运行时才炸,而 Go 把这件事压到了编译这一关。
接口本身是类型,这一点和 int、string 没有区别。它能当变量类型,能当函数参数,能当返回值,也能塞进切片当元素用。写业务代码的时候把它当成一个普通类型看就行,它占几个字节是编译器的事,跟你怎么用它没关系。
先把它当成一张清单。
没有 implements 这个词
拿方块开刀。定义 Sq 结构体,字段是边长,再加上两个方法,方法名、参数、返回值照着清单抄。接收者先都写成值,指针接收者的情况后面单独说。
1 | type Sq struct { |
两个方法写完,我没有在任何地方写一句 Sq 实现了 Shape。Go 里也没有地方可写,你找不到 implements,找不到 extends,也找不到一张注册表。想把方块当成形状用,直接赋值,var s Shape = Sq{3},编译器在赋值那一刻现场比对,方法够就放行。这一步发生在编译期,运行时没有这一趟检查,所以不用担心赋值慢了半拍。反过来说,只要方法对得上,这个类型在哪个包里定义、是不是你写的、有没有文档,全都不影响它能不能装进去。标准库里的接口能被你自己的类型满足,靠的就是这一条。这种反过来的关系一开始让我很不习惯,接口不知道谁实现了它,实现它的类型也不提接口的名字。后来才明白好处在哪,接口可以后补,一段写好的类型,等有人需要某个清单的时候,它自己就符合了,不用回头去改类型定义。
打出来的第一行是 9,第二行是 square,第三行 %T 打的是 main.Sq。装进去的是方块,不是形状,Shape 这三个字一次都没露过面。
1 | $ go run . |
少一个方法就装不进去
现在故意搞一次破坏。把 Name 那个方法删掉,只留 Area,别的地方一个都不动,还是那句 var s Shape = Sq{3}。
1 | type Sq struct { |
编译器报出来的这一句长得吓人,可该看的地方就三段。开头 .\main.go:15:16 是文件、行、列,行号正好是你写赋值那一行。中间说你把一个 Sq 结构体的值当成 Shape 使了,用在变量声明里。后面那句才是真正的原因,Sq does not implement Shape,括号里补了一刀,missing method Name,缺的是 Name 这个方法。不绕弯,直接点名缺谁,连去找的功夫都给你省了。
1 | $ go run . |
还有一种情况是方法在,但是长得不对。把 Name 的返回值从 string 改成 int,报错立刻换成另一句,底下多出两行 have 和 want,把两边并排放着给你看。
1 | $ go run . |
have 是你现在写的,want 是清单上要的。这两行前面缩进两个 Tab,中间没有别的字,就这么干巴巴地摆着,差别在哪里一眼就看得出来。参数个数不对的时候也是这个模板,have 后面会多出一个括号,want 那边还是空的。
几种说法其实是同一个模板,前半句永远是 Sq does not implement Shape,真正有用的信息全在括号里。
认括号里那半句就行。
| 括号里写的 | 意思 | 怎么改 |
|---|---|---|
| missing method Name | 根本没有这个方法 | 补一个方法上去 |
| wrong type for method Name | 方法在,签名不对 | 参数和返回值照清单改 |
| method Area has pointer receiver | 方法绑在指针上 | 改接收者,或者传地址 |
表格第三行那种情况,方法真的写了,只是写在了指针接收者上,赋值的时候传的又是值而不是地址,编译一样不过。
1 | $ go run . |
这一条入门阶段先记住有这回事,等把方法集那一节补上再说。
一个函数,收两种形状
接口真正好用的地方在这里。写一个 Describe(s Shape) string,它只认 Shape 这张清单,里面调 s.Name() 和 s.Area()。传方块进去能算,传圆进去也能算,函数体一个字都不用改。以后往这个函数里塞第三种形状,只要它有两个方法,Describe 那一行不用动。反过来说,谁的方法少一个,连编译这一关都过不去,不会等到半夜在生产环境上才炸。这就是多态在 Go 里的全部内容,没有继承树,也没有虚函数表,只有一张清单,和一堆各自把方法长齐了的类型。你甚至不需要知道 Shape 有几个实现,加实现的时候也不用回头改 Shape 那个文件,两边的代码可以完全不认识对方,只要它们都认识那张清单。测试的时候塞一个假的进去,跑完再换回来,用的就是这一手。
1 | func Describe(s Shape) string { |
1 | $ go run . |
any 是空接口,什么都能装
有一个接口一个方法都不要求,它叫空接口,写出来是 interface{},Go 1.18 之后给了它一个别名 any,两个写法完全等价。清单是空的,所有类型都对得上,所以什么都能往里塞。打印的时候 %T 看类型,%v 看值,两个占位符一起用就能看清楚里面到底装了什么。标准库里到处是它,fmt.Println 的参数就写成了 ...any,你传多少个、传什么类型都行,靠的正是这一条。空接口不是万能工具,它把类型信息藏起来了,用的时候要一层层问回来。写库的时候参数收 any 很省事,用的人却要在自己那边写断言,麻烦只是换了个地方。所以标准库里像 sort.Slice 那样的签名,收 any 是有代价的设计,能写具体接口就别写空接口。
1 | var x any = 42 |
同一个变量,前两行装整数,后两行装字符串,类型一路跟着变。x 的静态类型从头到尾都是 any,可里面装的东西一直在换,换的时候没有任何提示。
1 | $ go run . |
切片那三行更明显,一个 []any 里躺着整数、字符串、布尔,三种毫不相干的东西并排站着。数组和切片要求元素同类型,这里同的只是接口这一层,往下各是各的。
能装是能装,可装进去之后,能用的方法只剩清单上那几条,空清单上半条都没有,所以你连加都加不了。想用原来那个类型的功能,得先问一句里面到底是什么。
断言:问一次类型,拿一次值
想拿回原来的类型,得用类型断言,写法是 x.(T),问一句这个接口变量里装的是不是 T。带上 ok 的写法一次给两个结果,一个值,一个布尔,成功失败都不用中断程序。
1 | var x any = 42 |
三行的形状一模一样,结果全不一样。第一行拿回 42,ok 是 true。第二行问的是字符串,里面装的是整数,ok 变成 false,可变量还是有值,是个空字符串,用 %q 打出来是两对引号。第三行问布尔,同样 false,值是最没用的那个 false。
零值不是没有,是那一类的最小值。
不带 ok 的写法只有一半,v := x.(string),问不中直接崩。这不是吓唬人,程序停在那里,栈上只留下几行线索:第一行说 interface conversion,interface {} is int, not string,里面装的是整数,你要的是字符串。下面那几行是现场,从 main.main 开始,指着出事那一行的路径和行号,是 main.go 第 7 行。程序到这儿就停了,exit status 2,后面的代码一行都没跑。要命的是这种崩通常在线上才出现,本地那几条测试路径没走到,就一直看不见。
1 | $ go run . |
所以日常写代码,只要有一点点不确定,就用带 ok 的那一版。不确定才是常态,接口变量里装的是什么,往往是上一个函数决定的,你在这个函数里看不见。
两句写法,差一次崩溃。
断言的目标也可以是一个接口,x.(Shape) 问的是里面装的那东西满不满足 Shape。通过了就还你一个静态类型是 Shape 的值,可它里面装的还是原来那个具体类型,%T 打出来照样是 main.Sq,这一点最容易看岔。往窄里问也行,写成 x.(interface{ Area() float64 }),只要方法够就通过,不用为了问一次专门定义个接口。这一趟会重做一次方法比对,跟赋值那一次是一回事,只不过方向反过来。
type switch:一次问一串
要连着问好几个类型,用 if 一层层套太丑。Go 给了个专门的写法,switch v := x.(type),注意括号里是 type 不是某个具体类型,它只能长在 switch 头上。每个 case 写一个类型,匹配上的那个分支里,v 已经是那个类型了,不用再断言一次。
1 | func Show(x any) { |
拿四种东西喂进去,整数、字符串、布尔,外加一个浮点数。前三个各走各的分支,浮点数没有自己的坑位,落进 default,第四行就是它打的,%T 说的是 float64。没写 case 的类型不会凭空消失,它照样进得来,只是在 switch 里没地方去,被兜底接住了。这也是 default 值得写的原因,可以借它打一行日志,看看线上到底还有哪些类型在往里塞。
1 | $ go run . |
每个分支里的 v 类型都不一样,int 那个分支里能直接做加法,string 那个分支里能直接取长度,编译器早就替你换好了,不用再写一遍断言。写起来比一串 if 干净,而且漏了某个类型的时候,default 那一眼就能看出来现在还收着哪些意料之外的东西。
接口可以拼起来
接口能嵌接口。标准库里最常用的两个是 io.Reader 和 io.Writer,一个只有 Read(p []byte) (int, error),一个只有 Write(p []byte) (int, error)。把它们嵌进一个新的接口,新清单就是这两个方法,谁长齐了谁进得来。
1 | type ReadWriter interface { |
写一个 Buf,两个方法都实现,用指针接收者。它能装进 ReadWriter,也能单独装进 io.Reader 或者 io.Writer,装进哪一个,外面能看见的就只有那一个的方法。第 2 行读回来 5 个字节,第 3 行写进去 2 个,剩下两行 %T 打出来都是 *main.Buf,说明装进不同接口的确实是同一个东西。这也是标准库里的函数参数写得那么窄的原因,一个函数只要读,就只要求 io.Reader,你能传的东西就多得多,文件、网络连接、字符串缓冲,全都能进。这种拼法在标准库里到处都是,os.File 同时满足 io.Reader、io.Writer 和 io.Closer,一个类型能进好几个接口,装进哪个由你当场决定。接口拆得细,能接住的东西就多,需要几个就拼几个,这也是标准库里的接口普遍只有一个方法的原因。
1 | $ go run . |
组合接口也不是白拼的,让一个只有 Write 的 Sink 去装 ReadWriter,编译直接不过,缺的那个方法是从 io.Reader 带过来的。
1 | $ go run . |
标准库里还有一堆这样的小接口,fmt.Stringer 只有一个 String() string,自己给某个类型写上这个方法,fmt.Println 打它的时候就会改用 String() 的结果,不用你手动调。
下一篇换一个方向,讲错误怎么当一个普通的返回值往回传。












