35. Go 语言中关于接口的三个"潜规则"

Hi，你们好，我是明哥。

在本身学习 Golang 的这段时间里，我写了详细的学习笔记放在个人我的微信公众号 《Go编程时光》，对于 Go 语言，我也算是个初学者，所以写的东西应该会比较适合刚接触的同窗，若是你也是刚学习 Go 语言，不防关注一下，一块儿学习，一块儿成长。

个人在线博客：http://golang.iswbm.com
个人 Github：github.com/iswbm/GolangCodingTime

1. 对方法的调用限制

接口是一组固定的方法集，因为静态类型的限制，接口变量有时仅能调用其中特定的一些方法。

请看下面这段代码

package main

import "fmt"

type Phone interface {
    call()
}

type iPhone struct {
    name string
}

func (phone iPhone)call()  {
    fmt.Println("Hello, iPhone.")
}

func (phone iPhone)send_wechat()  {
    fmt.Println("Hello, Wechat.")
}

func main() {
    var phone Phone
    phone = iPhone{name:"ming's iphone"}
    phone.call()
    phone.send_wechat()
}

我定义了一个 Phone 的接口，只要求实现 call 方法便可，也就是只要能打电话的设备就是一个电话（好像是一句没用的废话）。

而后再定义了一个 iPhone 的结构体，该结构体接收两个方法，一个是打电话（ call 函数），一个是发微信（send_wechat 函数）。

最后一步是关键，咱们定义了一个 Phone 接口类型的 phone 对象，该对象的内容是 iPhone 结构体。而后咱们调用该对象的 call 方法，一切正常。

可是当你调用 phone.send_wechat 方法，程序会报错，提示咱们 Phone 类型的方法没有 send_wechat 的字段或方法。

# command-line-arguments
./demo.go:30:10: phone.send_wechat undefined (type Phone has no field or method send_wechat)

缘由也很明显，由于咱们的phone对象显示声明为 Phone 接口类型，所以 phone调用的方法会受到此接口的限制。

那么如何让 phone 能够调用 send_wechat 方法呢？

答案是能够不显示的声明为 Phone接口类型 ，但要清楚 phone 对象其实是隐式的实现了 Phone 接口，如此一来，方法的调用就不会受到接口类型的约束。

修改 main 方法成以下

func main() {
    phone := iPhone{name:"ming's iphone"}
    phone.call()
    phone.send_wechat()
}

运行后，一切正常，没有报错。

Hello, iPhone.
Hello, Wechat.

2. 调用函数时的隐式转换

Go 语言中的函数调用都是值传递的，变量会在方法调用前进行类型转换。

好比下面这段代码

import (
    "fmt"
)

func printType(i interface{})  {

    switch i.(type) {
    case int:
        fmt.Println("参数的类型是 int")
    case string:
        fmt.Println("参数的类型是 string")
    }
}

func main() {
    a := 10
    printType(a)
}

若是你运行后，会发现一切都很正常

参数的类型是 int

可是若是你把函数内的内容搬到到外面来

package main

import "fmt"


func main() {
    a := 10

    switch a.(type) {
    case int:
        fmt.Println("参数的类型是 int")
    case string:
        fmt.Println("参数的类型是 string")
    }
}

就会有意想不到的结果，竟然报错了。

# command-line-arguments
./demo.go:9:5: cannot type switch on non-interface value a (type int)

这个操做会让一个新人摸不着头脑，代码逻辑都是同样的，为何一个不会报错，一个会报错呢？

缘由其实很简单。

当一个函数接口 interface{} 空接口类型时，咱们说它能够接收什么任意类型的参数（江湖上称之为无招胜有招）。

当你使用这种写法时，Go 会默默地为咱们作一件事，就是把传入函数的参数值（注意：Go 语言中的函数调用都是值传递的）的类型隐式的转换成 interface{} 类型。

如何进行接口类型的显示转换

上面了解了函数中 接口类型的隐式转换后，你的内心可能开始有了疑问了，难道我使用类型断言，只能经过一个接收空接口类型的函数才能实现吗？

答案固然是 No.

若是你想手动对其进行类型转换，能够像下面这样子，就能够将变量 a 的静态类型转换为 interface{} 类型而后赋值给 b （此时 a 的静态类型仍是 int，而 b 的静态类型为 interface{}）

var a int = 25
b := interface{}(a)

知道了方法后，将代码修改为以下：

package main

import "fmt"


func main() {
    a := 10

    switch interface{}(a).(type) {
    case int:
        fmt.Println("参数的类型是 int")
    case string:
        fmt.Println("参数的类型是 string")
    }
}

运行后，一切正常。

参数的类型是 int

3. 类型断言中的隐式转换

上面咱们知道了，只有静态类型为接口类型的对象才能够进行类型断言。

而当类型断言完成后，会返回一个静态类型为你断言的类型的对象，也就是说，当咱们使用了类型断言，Go 实际上又会默认为咱们进行了一次隐式的类型转换。

验证方法也很简单，使用完一次类型断言后，对返回的对象再一次使用类型断言，Goland 立马就会提示咱们新对象 b 不是一个接口类型的对象，不容许进行类型断言。

---