10 面向对象 - interface - HelloWorld开发者社区

interface

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

什么是interface

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

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

package main

import "fmt"

//一个介绍自己的接口，里面有一个方法showMe
type IShow interface {
    showMe()
}

//一个工作内容的接口
type IWork interface {
    doSomething()
}

type Student struct {
    Name string
}

type Employee struct {
    Name string
}

//Student实现了showMe方法
func (s Student) showMe() {
    fmt.Printf("我是一个学生， 我的名字是：%s
", s.Name)
}

//Student实现了IWork接口
func (s Student) doSomething() {
    fmt.Printf("我是学生，我每天的做的事就是学习
")
}

//Employee实现了showMe方法
func (e Employee) showMe() {
    fmt.Printf("我是一个工人，我的名字是：%s
", e.Name)
}

func (e Employee) doSomething() {
    fmt.Printf("我是工人，我每天的做的事就是赚钱养家
")
}

func main() {
    //分别创建Student和Employee实例
    s := Student{Name: "小明"}
    e := Employee{Name: "tom"}

    //声明一个接口IShow的变量
    var ishow IShow
    var iwork IWork

    //将 s 赋值给 ishow
    ishow = s
    ishow.showMe()

    iwork = s
    iwork.doSomething()

    //将 e 赋值给ishow
    ishow = e
    ishow.showMe()

    iwork = e
    iwork.doSomething()
}

打印如下

我是一个学生， 我的名字是：小明
我是学生，我每天的做的事就是学习
我是一个工人，我的名字是：tom
我是工人，我每天的做的事就是赚钱养家

通过上面的例子，可以知道

interface可以被任意对象实现
对象可以实现任意一个或者多个接口

那么 interface 里面到底能存什么值呢？如果我们定义了一个 interface 的变量，那么这个变量里面可以存实现这个 interface 的任意类型的对象比如上面变量ishow，就可以保存实现了其接口的Student和Employee变量，并且在运行时调用不同的对象的方法，和java面向对象中的多态一样

通过上面的代码，你会发现

interface 就是一组抽象方法的集合
它必须由其他非 interface类型实现，而不能自我实现

go 通过 interface 实现了 duck-typing:即"当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。

空 interface

空 interface(interface{})不包含任何的 method，正因为如此，所有的类型都实现了空interface

空interface 对于描述起不到任何的作用(因为它不包含任何的method）

但是空interface 在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于 C 语言的 void*类型，也有点类似Java语言中的Object

// 定义 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
}

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

package main

import (
    "fmt"
    "strconv"
)

type Student struct {
    Name string
    Age int
}

//实现接口Stringer中的String方法
func (s Student)String() string {
    return "<" + "name=" + s.Name + " age=" + strconv.Itoa(s.Age) + ">"
}

func main()  {
    s := Student{Name:"小明",Age :18}
    fmt.Println(s)
}

interface 变量存储的类型

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

ok断言
switch 测试

先看第一种 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       //  int
    list[1] = "Hello" //  string
    list[2] = Person{"Dennis", 70}

    for index, element := range list {
        if value, ok := element.(int); ok {
            fmt.Printf("list[%d]是int类型，值是:%d
", index, value)
        } else if value, ok := element.(string); ok {
            fmt.Printf("list[%d]是string类型，值是：%s
", index, value)
        } else if value, ok := element.(Person); ok {
            fmt.Printf("list[%d]是Person类型，值是： %s
", index, value)
        } else {
            fmt.Println("list[%d]是其它类型
", index)
        }
    }
}

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

也许你注意到了，我们断言的类型越多，那么 if else 也就越多，所以才引出了下面要介绍的 switch 还是上面的代码，只需要把for注释，再换成switch就可以了，如下：

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       //  int
    list[1] = "Hello" //  string
    list[2] = Person{"Dennis", 70}

    /**
    for index, element := range list {
        if value, ok := element.(int); ok {
            fmt.Printf("list[%d]是int类型，值是:%d
", index, value)
        } else if value, ok := element.(string); ok {
            fmt.Printf("list[%d]是string类型，值是：%s
", index, value)
        } else if value, ok := element.(Person); ok {
            fmt.Printf("list[%d]是Person类型，值是： %s
", index, value)
        } else {
            fmt.Println("list[%d]是其它类型
", index)
        }
    }**/

    for index, element := range list{
        switch value := element.(type) {
        case int:
            fmt.Printf("list[%d]是int类型，值是:%d
", index, value)
        case string:
            fmt.Printf("list[%d]是string类型，值是：%s
", index, value)
        case Person:
            fmt.Printf("list[%d]是Person类型，值是： %s
", index, value)
        default:
            fmt.Println("list[%d]是其它类型
", index)
        }
    }
}

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

嵌入 interface

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

我们可以看到源码 io.go 里面有这样的一个定义:

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

接口ReadWriter就包含了Reader和Writer 2个接口

反射

Go 语言实现了反射，所谓反射就是动态运行时的状态。我们一般用到的包是 reflect 包。如何运用 reflect 包，官方的这篇文章详细的讲解了 reflect 包的实现原理 https://blog.golang.org/laws-of-reflection

使用 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())

输出：

type: float64
kind is float64: true
value: 3.4

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

如果下面这样写，那么会发生错误

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)

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