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

作者：神奇cpp | 2024-07-31 08:35:11

踩

go 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)

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/907929