Go 方法、接口

 

 

 

在 Go 中，类型可以定义接收此类型的函数，即方法。每个类型都有接口，意味着对那个类型定义了方法集合。

下面定义了结构体类型 S 以及它的两个方法：

type S struct { i int }
func (p *S) Get() int { return p.i }
func (p *S) Put(v int) { p.i = v }

方法

方法就是有接收者的函数。

可以在除了非本地类型（包括内建类型，比如 int）的任意类型上定义方法。然而可以为内建类型定义别名，然后就可以为别名定义方法。如

type Foo int // 为 int 定义别名 Foo
func (self Foo) Emit() {
    fmt.Printf("%v", self)
}

接口

接口定义为一个方法的集合。方法包含实际的代码。换句话说，一个接口就是定义，而方法就是实现。因此，接收者不能定义为接口类型，这样做的话会引起 invalid receiver type … 的编译器错误。

来自语言说明书的权威内容：

接收者类型必须是T 或*T，这里的 T 是类型名。 T 叫做接收者基础类型或简称基础类型。基础类型一定不能是指针或接口类型，并且定义在与方法相同的包中。

// 定义了有两个方法的接口 I，结构 S 实现了此接口
type I interface {
    Get() int
    Put( int)
}

可以定义接口类型的变量（接口值）作为函数的参数，实现了此接口的类型的变量可以作为实参传递给该接口变量并调用其方法。

func f(p I) {
    fmt.Println(p.Get())
    p.Put(1)
}

var s S
f(&s) // S 类型的变量 s 作为实参传给接口。取地址是因为在 s 的指针上定义了方法，这样可以修改 s；
      // 如果在 s 上定义方法，则修改的只是 s 的副本

在 Go 中创建指向接口的指针是无意义的。创建接口值的指针也是非法的。

接口类型判断

在 Go 中，要判断传递给接口值的变量类型，可以在使用 type switch 得到。(type)只能在 switch 中使用。

// 另一个实现了 I 接口的 R 类型
type R struct { i int }
func (p *R) Get() int { return p.i }
func (p *R) Put(v int) { p.i = v }

func f(p I) {
    switch t := p.(type) { // 判断传递给 p 的实际类型
        case *S: // 指向 S 的指针类型
        case *R: // 指向 R 的指针类型
        case S:  // S 类型
        case R:  // R 类型
        default: //实现了 I 接口的其他类型
    }
}

若要在 switch 外判断一个接口类型是否实现了某个接口，可以使用“逗号 ok ”。

value, ok := Interfacevariable.(implementType)

其中 Interfacevariable 是接口变量（接口值），implementType 为实现此接口的类型，value 返回接口变量实际类型变量的值，如果该类型实现了此接口返回 true。

type I interface{ // 有一个方法的接口 I
    Get() Int
}

type Int int // Int 类型实现了 I 接口
func (i Int) Get() Int{
    return i
}

var myint Int = 5
var inter I = myint // 变量赋值给接口
val, ok := inter.(Int)
fmt.Printf("%v, %v", val, ok) // 输出为：5，true

空接口

每种类型都能匹配到空接口：interface{}。空接口类型对方法没有任何约束（因为没有方法），它能包含任意类型，也可以实现到其他接口类型的转换。如果传递给该接口的类型变量实现了转换后的接口则可以正常运行，否则出现运行时错误。

func g(si interface{}) int {
    return si.(I).Get()
}
s = new(S)
g(s) // (I) 将 si 转换到 I 类型的接口，s 实现了 Get 方法，因此可以调用 g()

i := 5
g(i) // 运行时出错，因为 int 型没有 Get 方法

还可以在接口中列出另一个接口，如

type Interface interface {
    sort.Interface // 另一个接口
    Push(x interface{})
    Pop() interface{}
}

自省和反射

…