go接口(一)

yitianyitian
98 阅读5分钟

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第16天，点击查看活动详情

1.接口是什么

Go 语言里有非常灵活的 接口 概念，通过它可以实现很多面向对象的特性。 接口定义了一组方法（方法集），但是这些方法不包含（实现）代码：它们没有被实现（它们是抽象的）。接口里也不能包含变量。

定义接口：

type Namer interface {
    Method1(param_list) return_type
    Method2(param_list) return_type
    ...
}

Namer 是一个 接口类型（按照约定，只包含一个方法的）接口的名字由方法名加 [e]r 后缀组成，例如 Printer、Reader、Writer、Logger、Converter 等等。还有一些不常用的方式（当后缀 er 不合适时），比如 Recoverable，此时接口名以 able 结尾，或者以 I 开头。Go 语言中的接口都很简短，通常它们会包含 0 个、最多 3 个方法。

类型不需要显式地声明它实现了某个接口，接口被隐式地实现，隐式接口解藕了实现接口的包和定义接口的包：互不依赖。

多个类型可以实现同一个接口，一个类型可以实现多个接口，实现了某个接口的类型，还可以有其它的方法。接口类型是由一组方法定义的集合。接口类型的值可以存放实现这些方法的任何值。类型（比如结构体）实现接口方法集中的所有方法，一定是接口方法集中所有方法。那么接口类型的值其实也可以存放该结构体的值。

package main
import (
    "fmt"
)
type A struct {
    Face int
}
type B interface {
    f()
}
func (a A) f() {
    fmt.Println("hi ", a.Face)
}
func main() {
    var s A = A{Face: 9}
    s.f()
    var b B = A{Face: 9}  //接口类型可接受结构体的值，因为结构体实现了接口
    b.f()
}

即使接口在类型之后才定义，二者处于不同的包中，被单独编译：只要类型实现了接口中的方法，它就实现了此接口。所有这些特性使得接口具有很大的灵活性。接口变量里包含了接收器实例的值和指向对应方法表的指针，也就是说接口实例上可以调用该实例方法，它使此方法更具有一般性。

注意：接口中的方法必须要全部实现，才能实现接口。

2.接口嵌套

一个接口可以包含一个或多个其他的接口，这相当于直接将这些内嵌接口的方法列举在外层接口中一样。但是在接口内不能内嵌结构体，编译会出错。比如接口 File 包含了 ReadWrite 和 Lock 的所有方法，它还额外有一个 Close() 方法。和结构体内嵌基本差不多。

type ReadWrite interface {
    Read(b Buffer) bool
    Write(b Buffer) bool
}
type Lock interface {
    Lock()
    Unlock()
}
type File interface {
    ReadWrite
    Lock
    Close()
}

3.类型断言

如何检测和转换接口变量的类型呢？这是类型断言（Type Assertion）就用上了。一个接口类型的变量 varI 中可以包含任何类型的值，必须有一种方式来检测它的 动态 类型，即运行时在变量中存储的值的实际类型。在执行过程中动态类型可能会有所不同，但是它总是可以分配给接口变量本身的类型。通常我们可以使用 类型断言 来测试在某个时刻接口变量 varI 是否包含类型 T 的值：

v := varI.(T)       // unchecked type assertion

varI 必须是一个接口变量，否则编译器会报错：invalid type assertion: varI.(T) (non-interface type (type of varI) on left) 。

Go 语言中的所有程序都实现了interface{}的接口，这意味着，所有的类型如string, int, int64甚至是自定义的struct类型都就此拥有了interface{}的接口，这种做法和java中的Object类型比较类似。那么在一个数据通过func funcName(interface{})的方式传进来的时候，也就意味着这个参数被自动的转为interface{}的类型。

func funcName(a interface{}) string {
     return string(a)
}

类型断言可能是无效的，虽然编译器会尽力检查转换是否有效，但是它不可能预见所有的可能性。如果转换在程序运行时失败会导致错误发生。更安全的方式是使用以下形式来进行类型断言：

if v, ok := varI.(T); ok {  // 类型断言检查
    Process(v)
    return
}

如果转换合法，v 是 varI 转换到类型 T 的值，ok 会是 true；否则 v 是类型 T 的零值，ok 是 false，也没有运行时错误发生。

  • 类型判断：type-switch

接口变量的类型也可以使用一种特殊形式的 switch 来检测：type-switch

switch t := areaIntf.(type) {
case *Square:
    fmt.Printf("Type Square %T with value %v\n", t, t)
case *Circle:
    fmt.Printf("Type Circle %T with value %v\n", t, t)
case nil:
    fmt.Printf("nil value: nothing to check?\n")
default:
    fmt.Printf("Unexpected type %T\n", t)
}

可以用 type-switch 进行运行时类型分析，但是在 type-switch 不允许有 fallthrough 。

在处理来自于外部的、类型未知的数据时，比如解析诸如 Json 或 XML 编码的数据，类型测试和转换会非常有用。

  • 测试一个值是否实现了某个接口

我们想测试它是否实现了 Stringer 接口，可以这样做：

type Stringer interface {
    String() string
}
if sv, ok := v.(Stringer); ok {
    fmt.Printf("v implements String(): %s\n", sv.String()) 
}

Print 函数就是如此检测类型是否可以打印自身的。

接口是一种契约，实现类型必须满足它，它描述了类型的行为，规定类型可以做什么。接口彻底将类型能做什么，以及如何做分离开来，使得相同接口的变量在不同的时刻表现出不同的行为，这就是多态的本质。

编写参数是接口变量的函数，这使得它们更具有一般性。

使用接口使代码更具有普适性。

标准库里到处都使用了这个原则，如果对接口概念没有良好的把握，是不可能理解它是如何构建的。

avatar
文章
阅读
粉丝