什么是interface
在面向对象编程中，可以这么说：“接口定义了对象的行为”， 那么具体的实现行为就取决于对象了。
在Go中，接口是一组方法签名(声明的是一组方法的集合)。当一个类型为接口中的所有方法提供定义时，它被称为实现该接口。它与oop非常相似。接口指定类型应具有的方法，类型决定如何实现这些方法。
type Animal interface {
Speak() string
}
定义 Animal 为任何具有 Speak 方法的类型。Speak 方法没有参数，返回一个字符串。所有定义了该方法的类型我们称它实现了 Animal 接口。Go 中没有 implements 关键字，判断一个类型是否实现了一个接口是完全是自动地。让我们创建几个实现这个接口的类型：
type Dog struct {
}
func (d Dog) Speak() string {
return "Woof!"
}
type Cat struct {
}
func (c Cat) Speak() string {
return "Meow!"
}
type Llama struct {
}
func (l Llama) Speak() string {
return "?????"
}
type JavaProgrammer struct {
}
func (j JavaProgrammer) Speak() string {
return "Design patterns!"
}
现在有四种不同类型的动物：Dog、Cat、Llama 和 JavaProgrammer。在我们的 main 函数中，我们创建了一个 []Animal{Dog{}, Cat{}, Llama{}, JavaProgrammer{}} ，看看每只动物都说了些什么：
func main() {
animals := []Animal{Dog{}, Cat{}, Llama{}, JavaProgrammer{}}
for _, animal := range animals {
fmt.Println(animal.Speak())
}
}
interface{} 类型
interface{} 类型，空接口，是导致很多混淆的根源。interface{} 类型是没有方法的接口。由于没有 implements 关键字，所以所有类型都至少实现了 0 个方法，所以 所有类型都实现了空接口。这意味着，如果您编写一个函数以 interface{} 值作为参数，那么您可以为该函数提供任何值。例如：
func DoSomething(v interface{}) {
// ...
}
DoSomething 函数内部，v 的类型是什么？新手们会认为 v 是任意类型的，但这是错误的。v 不是任意类型，它是 interface{} 类型。对的，没错！当将值传递给DoSomething 函数时，Go 运行时将执行类型转换(如果需要)，并将值转换为 interface{} 类型的值。所有值在运行时只有一个类型，而 v 的一个静态类型是 interface{} 。interface{} 的值呢？（具体到上例来说就是 []Animal 中存的是啥？）一个接口值由两个字（32 位机器一个字是 32 bits，64 位机器一个字是 64 bits）组成；一个字用于指向该值底层类型的方法表，另一个字用于指向实际数据
在我们上面的例子中，当我们初始化变量 animals 时，我们不需要像这样 Animal(Dog{}) 来显示的转型，因为这是自动地。这些元素都是 Animal 类型，但是他们的底层类型却不相同。
为什么这很重要呢？理解接口是如何在内存中表示的，可以使得一些潜在的令人困惑的事情变得非常清楚。比如，像 “我可以将 []T 转换为 []interface{}
吗？” 这种问题就容易回答了。下面是一些烂代码的例子，它们代表了对 interface{} 类型的常见误解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package mainimport ( "fmt")func PrintAll(vals []interface{}) { for _, val := range vals { fmt.Println(val) }}func main() { names := []string{"stanley", "david", "oscar"} PrintAll(names)} |
运行这段代码你会得到如下错误：cannot use names (type []string) as type []interface {} in argument to PrintAll。如果想使其正常工作，我们必须将 []string 转为 []interface{}：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package mainimport ( "fmt")func PrintAll(vals []interface{}) { for _, val := range vals { fmt.Println(val) }<br>}func main() { names := []string{"stanley", "david", "oscar"} vals := make([]interface{}, len(names)) for i, v := range names { vals[i] = v } PrintAll(vals)} |
很丑陋，但是生活就是这样，没有完美的事情。（事实上，这种情况不会经常发生，因为 []interface{} 并没有像你想象的那样有用）
指针和接口
Cat 的 Speak() 方法改为指针接收器：|
1
2
3
|
func (c *Cat) Speak() string { return "Meow!"} |
运行上述代码，会得到如下错误：
|
1
2
|
cannot use Cat literal (type Cat) as type Animal in array or slice literal: Cat does not implement Animal (Speak method has pointer receiver) |
该错误的意思是：你尝试将 Cat 转为 Animal ，但是只有 *Cat 类型实现了该接口。你可以通过传入一个指针 （new(Cat) 或者 &Cat{}）来修复这个错误。
|
1
|
animals := []Animal{Dog{}, new(Cat), Llama{}, JavaProgrammer{}} |
让我们做一些相反的事情：我们传入一个 *Dog 指针，但是不改变 Dog 的 Speak() 方法：
|
1
|
animals := []Animal{new(Dog), new(Cat), Llama{}, JavaProgrammer{}} |
这种方式可以正常工作，因为一个指针类型可以通过其相关的值类型来访问值类型的方法，但是反过来不行。即，一个 *Dog 类型的值可以使用定义在 Dog 类型上的 Speak() 方法，而 Cat 类型的值不能访问定义在 *Cat 类型上的方法。
这可能听起来很神秘，但当你记住以下内容时就清楚了：Go 中的所有东西都是按值传递的。每次调用函数时，传入的数据都会被复制。对于具有值接收者的方法，在调用该方法时将复制该值。例如下面的方法：
|
1
2
3
|
func (t T)MyMethod(s string) { // ...} |
是 func(T, string) 类型的方法。方法接收器像其他参数一样通过值传递给函数。
*Cat 的方法不能被 Cat 类型的值调用了。任何一个 Cat 类型的值可能会有很多 *Cat 类型的指针指向它，如果我们尝试通过 Cat 类型的值来调用 *Cat 的方法，根本就不知道对应的是哪个指针。相反，如果 Dog 类型上有一个方法，通过 *Dog 来调用这个方法可以确切的找到该指针对应的 Gog 类型的值，从而调用上面的方法。运行时，Go 会自动帮我们做这些，所以我们不需要像 C语言中那样使用类似如下的语句 d->Speak() 。package main
import "fmt"
import "math"
// 几何图形的接口(interface)
type geometry interface {
area() float64
perim() float64
}
// rect 和 circle 实现 geometry 接口
type rect struct {
width, height float64
}
type circle struct {
radius float64
}
// 实现了接口中声明的所有方法即实现了该接口，这里 rects 实现了 geometry 接口
func (r rect) area() float64 {
return r.width * r.height
}
func (r rect) perim() float64 {
return 2*r.width + 2*r.height
} // circles 实现 geometry 接口
func (c circle) area() float64 {
return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
return 2 * math.Pi * c.radius
}
// 定义的接口可以作为一种数据类型，当一个变量的类型为一个接口类型时，这个变量可以调用接口中定义的方法。
// 这里定义一个函数，接收一个类型为 geometry 的参数变量
func measure(g geometry) {
fmt.Println(g)
fmt.Println(g.area())
fmt.Println(g.perim())
}
func main() {
r := rect{ 3, height: 4}
c := circle{radius: 5} // The circle and rect struct types both implement the geometry interface so we can use instances of these structs as arguments to measure.
// rect 和 circle 结构类型都实现了 geometry 接口，所以我们能够把它们的对象作为参数传给 measure 函数
// 在 measure 函数内部，参数对象调用了所属类型实现的接口方法。
measure(r)
measure(c)
}
结语
我希望读完此文后你可以更加得心应手地使用 Go 中的接口，记住下面这些结论：
- 通过考虑数据类型之间的相同功能来创建抽象，而不是相同字段
interface{}的值不是任意类型，而是interface{}类型- 接口包含两个字的大小，类似于
(type, value) - 函数可以接受
interface{}作为参数，但最好不要返回interface{} - 指针类型可以调用其所指向的值的方法，反过来不可以
- 函数中的参数甚至接受者都是通过值传递
- 一个接口的值就是就是接口而已，跟指针没什么关系
- 如果你想在方法中修改指针所指向的值，使用
*操作符