go语言学习日记【三十三】golang中interface详解

什么是interface：

        interface是一组方法的组合。我们可以通过interface定义对象的一组行为。

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) //Yes you can split into 2 lines here.
}


//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 和 YonggChap 两个 interface。 最后，任意的类型都实现了空 interface(我们这样定义：interface{})，也就是包含 0 个 method 的 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) //Yes you can split into 2 lines here.
 }


// 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{"Sam", 36, "444-222-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)
    //T 这三个都是不同类型的元素，但是他们实现了 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)
}


/***************************************************************
This Human is :  ❰Bob - 39 years - ✆ 000-7777-XXX❱
***************************************************************/

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.Println("list[%d] is of a different type", index)
        }
    }
}

        也许你注意到了，我们断言的类型越多，那么 ifelse 也就越多，所以才引出了下面要介绍 的 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 := 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.Println("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)
}

反射

        Go 语言实现了反射，所谓反射就是动态运行时的状态。我们一般用到的包是 reflect 包。reflect 一般分成三步，下面简要的讲解一下：要去反射是一个类型的值(这些值都实现 了空 interface)，首先需要把它转化成 reflect 对象(reflect.Type 或者 reflect.Value，根据不同的情况调用不同的函数)。这两种获取方式如下：

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

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

tag := t.Elem().Field(0).Tag //获取定义在 struct 里面的标签
name := 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)

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