interface

Go 语言里面设计最精妙的应该算 interface，它让面向对象，内容组织实现非常的方便，当你看完这一章，你就会被 interface 的巧妙设计所折服。

什么是 interface

简单的说，interface 是一组 method 签名的组合，我们通过 interface 来定义对象的一组行为。

我们前面一章最后一个例子中 Student 和 Employee 都能 SayHi，虽然他们的内部实现不一样，但是那不重要，重要的是他们都能 say hi

让我们来继续做更多的扩展，Student 和 Employee 实现另一个方法 Sing，然后 Student 实现方法 BorrowMoney 而 Employee 实现 SpendSalary。

这样 Student 实现了三个方法：SayHi、Sing、BorrowMoney；而 Employee 实现了 SayHi、Sing、SpendSalary。

上面这些方法的组合称为 interface (被对象 Student 和 Employee 实现)。例如 Student 和 Employee 都实现了 interface：SayHi 和 Sing，也就是这两个对象是该 interface 类型。而 Employee 没有实现这个 interface：SayHi、Sing 和 BorrowMoney，因为 Employee没有实现 BorrowMoney 这个方法。

interface 类型

interface 类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。详细的语法参考下面这个例子

type Human struct {
    name string
    age int
    phone string
}

type Student struct {
    Human // 匿名字段 Human
    school string
    loan float32
}

type Employee struct {
    Human // 匿名字段 Human
    company string
    money float32
}

// Human 对象实现 Sayhi 方法
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

// Human 对象实现 Sing 方法
func (h *Human) Sing(lyrics string) {
    fmt.Println("La la, la la la, la la la la la...", lyrics)
}

// Human 对象实现 Guzzle 方法
func (h *Human) Guzzle(beerStein string) {
    fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
}

// Employee 重载 Human 的 Sayhi 方法
func (e *Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
        e.company, e.phone) // 此句可以分成多行
}

// Student 实现 BorrowMoney 方法
func (s *Student) BorrowMoney(amount float32) {
    s.loan += amount // (again and again and...)
}

// Employee 实现 SpendSalary 方法
func (e *Employee) SpendSalary(amount float32) {
    e.money -= amount // More vodka please!!! Get me through the day!
}

// 定义 interface
type Men interface {
    SayHi()
    Sing(lyrics string)
    Guzzle(beerStein string)
}

type YoungChap interface {
    SayHi()
    Sing(song string)
    BorrowMoney(amount float32)
}

type ElderlyGent interface {
    SayHi()
    Sing(song string)
    SpendSalary(amount float32)
}

通过上面的代码我们可以知道，interface 可以被任意的对象实现。我们看到上面的 Men interface 被 Human、Student 和 Employee 实现。同理，一个对象可以实现任意多个 interface，例如上面的 Student 实现了 Men 和 YoungChap 两个 interface。

最后，任意的类型都实现了空 interface (我们这样定义：interface{})，也就是包含 0 个 method 的 interface。

interface 值

那么 interface 里面到底能存什么值呢？如果我们定义了一个 interface 的变量，那么这个变量里面可以存实现这个 interface 的任意类型的对象。例如上面例子中，我们定义了一个 Men interface 类型的变量 m，那么 m 里面可以存 Human、Student 或者 Employee 值。

因为 m 能够持有这三种类型的对象，所以我们可以定义一个包含 Men 类型元素的 slice，这个 slice 可以被赋予实现了 Men 接口的任意结构的对象，这个和我们传统意义上面的 slice 有所不同。

让我们来看一下下面这个例子:

package main

import "fmt"

type Human struct {
    name string
    age int
    phone string
}

type Student struct {
    Human // 匿名字段
    school string
    loan float32
}

type Employee struct {
    Human // 匿名字段
    company string
    money float32
}

// Human 实现 SayHi 方法
func (h Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

// Human 实现 Sing 方法
func (h Human) Sing(lyrics string) {
    fmt.Println("La la la la...", lyrics)
}

// Employee 重载 Human 的 SayHi 方法
func (e Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
        e.company, e.phone)
    }

// Interface Men 被 Human, Student 和 Employee 实现
// 因为这三个类型都实现了这两个方法
type Men interface {
    SayHi()
    Sing(lyrics string)
}

func main() {
    mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
    tom := Employee{Human{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}

    // 定义 Men 类型的变量i
    var i Men

    // i 能存储 Student
    i = mike
    fmt.Println("This is Mike, a Student:")
    i.SayHi()
    i.Sing("November rain")

    // i 也能存储 Employee
    i = tom
    fmt.Println("This is tom, an Employee:")
    i.SayHi()
    i.Sing("Born to be wild")

    // 定义了 slice Men
    fmt.Println("Let's use a slice of Men and see what happens")
    x := make([]Men, 3)
    // 这三个都是不同类型的元素，但是他们实现了 interface 同一个接口
    x[0], x[1], x[2] = paul, sam, mike

    for _, value := range x{
        value.SayHi()
    }
}

通过上面的代码，你会发现 interface 就是一组抽象方法的集合，它必须由其他非 interface 类型实现，而不能自我实现， Go 通过 interface 实现了 duck-typing: 即 "当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。

空 interface

空 interface(interface{}) 不包含任何的 method，正因为如此，所有的类型都实现了空 interface。空 interface 对于描述起不到任何的作用 (因为它不包含任何的 method），但是空 interface 在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于 C 语言的 void* 类型。

// 定义 a 为空接口
var a interface{}
var i int = 5
s := "Hello world"
// a 可以存储任意类型的数值
a = i
a = s

一个函数把 interface{} 作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回 interface{}, 那么也就可以返回任意类型的值。是不是很有用啊！

interface 函数参数

interface 的变量可以持有任意实现该 interface 类型的对象，这给我们编写函数 (包括 method) 提供了一些额外的思考，我们是不是可以通过定义 interface 参数，让函数接受各种类型的参数。

举个例子：fmt.Println 是我们常用的一个函数，但是你是否注意到它可以接受任意类型的数据。打开 fmt 的源码文件，你会看到这样一个定义:

type Stringer interface {
     String() string
}

也就是说，任何实现了 String 方法的类型都能作为参数被 fmt.Println 调用,让我们来试一试

package main
import (
    "fmt"
    "strconv"
)

type Human struct {
    name string
    age int
    phone string
}

// 通过这个方法 Human 实现了 fmt.Stringer
func (h Human) String() string {
    return "❰"+h.name+" - "+strconv.Itoa(h.age)+" years -  ✆ " +h.phone+"❱"
}

func main() {
    Bob := Human{"Bob", 39, "000-7777-XXX"}
    fmt.Println("This Human is : ", Bob)
}

现在我们再回顾一下前面的 Box 示例，你会发现 Color 结构也定义了一个 method：String。其实这也是实现了 fmt.Stringer 这个 interface，即如果需要某个类型能被 fmt 包以特殊的格式输出，你就必须实现 Stringer 这个接口。如果没有实现这个接口，fmt 将以默认的方式输出。

// 实现同样的功能
fmt.Println("The biggest one is", boxes.BiggestsColor().String())
fmt.Println("The biggest one is", boxes.BiggestsColor())

注：实现了 error 接口的对象（即实现了 Error() string 的对象），使用 fmt 输出时，会调用 Error() 方法，因此不必再定义 String() 方法了。

interface 变量存储的类型

我们知道 interface 的变量里面可以存储任意类型的数值 (该类型实现了 interface)。那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？目前常用的有两种方法：

• Comma-ok 断言

  Go 语言里面有一个语法，可以直接判断是否是该类型的变量： value, ok = element.(T)，这里 value 就是变量的值，ok 是一个 bool 类型，element 是 interface 变量，T 是断言的类型。

  如果 element 里面确实存储了T类型的数值，那么 ok 返回 true，否则返回 false。

  让我们通过一个例子来更加深入的理解。

    package main
  
    import (
        "fmt"
        "strconv"
    )
  
    type Element interface{}
    type List [] Element
  
    type Person struct {
        name string
        age int
    }
  
    // 定义了 String 方法，实现了 fmt.Stringer
    func (p Person) String() string {
        return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
    }
  
    func main() {
        list := make(List, 3)
        list[0] = 1 // an int
        list[1] = "Hello" // a string
        list[2] = Person{"Dennis", 70}
  
        for index, element := range list {
            if value, ok := element.(int); ok {
                fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
            } else if value, ok := element.(string); ok {
                fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
            } else if value, ok := element.(Person); ok {
                fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
            } else {
                fmt.Printf("list[%d] is of a different type\n", index)
            }
        }
    }
  

  是不是很简单啊，同时你是否注意到了多个 if 里面，还记得我前面介绍流程时讲过，if 里面允许初始化变量。

  也许你注意到了，我们断言的类型越多，那么 if else 也就越多，所以才引出了下面要介绍的 switch。

• switch 测试

  最好的讲解就是代码例子，现在让我们重写上面的这个实现

    package main
  
    import (
        "fmt"
        "strconv"
    )
  
    type Element interface{}
    type List [] Element
  
    type Person struct {
        name string
        age int
    }
  
    // 打印
    func (p Person) String() string {
        return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
    }
  
    func main() {
        list := make(List, 3)
        list[0] = 1 // an int
        list[1] = "Hello" // a string
        list[2] = Person{"Dennis", 70}
  
        for index, element := range list{
            switch value,ok := element.(type) {
                case int:
                    fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
                case string:
                    fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
                case Person:
                    fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
                default:
                    fmt.Printf("list[%d] is of a different type", index)
            }
        }
    }
  

  这里有一点需要强调的是：element.(type) 语法不能在 switch 外的任何逻辑里面使用，如果你要在 switch 外面判断一个类型就使用 comma-ok。

嵌入 interface

Go 里面真正吸引人的是它内置的逻辑语法，就像我们在学习 Struct 时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到 interface 里面，那不是更加完美了。如果一个 interface1 作为 interface2 的一个嵌入字段，那么 interface2 隐式的包含了 interface1 里面的 method。

我们可以看到源码包 container/heap 里面有这样的一个定义

type Interface interface {
    sort.Interface // 嵌入字段 sort.Interface
    Push(x interface{}) // a Push method to push elements into the heap
    Pop() interface{} // a Pop elements that pops elements from the heap
}

我们看到 sort.Interface 其实就是嵌入字段，把 sort.Interface 的所有 method 给隐式的包含进来了。也就是下面三个方法：

type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less returns whether the element with index i should sort
    // before the element with index j.
    Less(i, j int) bool
    // Swap swaps the elements with indexes i and j.
    Swap(i, j int)
}

另一个例子就是 io 包下面的 io.ReadWriter ，它包含了 io 包下面的 Reader 和 Writer 两个 interface：

// io.ReadWriter
type ReadWriter interface {
    Reader
    Writer
}

反射

Go 语言实现了反射，所谓反射就是能检查程序在运行时的状态。我们一般用到的包是 reflect 包。如何运用 reflect 包，官方的这篇文章详细的讲解了 reflect 包的实现原理，laws of reflection

使用 reflect 一般分成三步，下面简要的讲解一下：要去反射是一个类型的值 (这些值都实现了空 interface)，首先需要把它转化成 reflect 对象 (reflect.Type 或者 reflect.Value，根据不同的情况调用不同的函数)。这两种获取方式如下：

t := reflect.TypeOf(i)    // 得到类型的元数据,通过t我们能获取类型定义里面的所有元素
v := reflect.ValueOf(i)   // 得到实际的值，通过 v 我们获取存储在里面的值，还可以去改变值

转化为 reflect 对象之后我们就可以进行一些操作了，也就是将 reflect 对象转化成相应的值，例如

name := t.Elem().Field(0).Name  // 获取定义在 struct 里面第一个字段的字段名
value := v.Elem().Field(0).String()  // 获取存储在第一个字段里面的值

获取反射值能返回相应的类型和数值

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
fmt.Println("value:", v.Float())

最后，反射的话，那么反射的字段必须是可修改的，我们前面学习过传值和传引用，这个里面也是一样的道理。反射的字段必须是可读写的意思是，如果下面这样写，那么会发生错误

var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1)

如果要修改相应的值，必须这样写

var x float64 = 3.4
p := reflect.ValueOf(&x)
v := p.Elem()
v.SetFloat(7.1)

上面只是对反射的简单介绍，更深入的理解还需要自己在编程中不断的实践。