GO基础-接口

接口

在学习一个新知识点时，我的初中政治老师曾教过我们一种方法，就是灵魂三问：是什么？为什么？怎么做？

是什么？

接口就是一组仅含有方法名、参数、返回值的未具体实现的方法集合。如果实现了接口的所有方法，则认为实现了该接口，无需在该类型上显示的添加声明。

type interfaceName interface { 
    // 方法列表 
    GetName() string
}

为什么？

多数情况下，数据可能包含不同的类型，却会有一个或者多个共同点，这些共同点就是抽象的基础。像是Golang继承解决的是is-a的问题，单一继承的关系。但是当不同的父类具有相同的行为的时候，单一继承就没法解决了。

于是乎，接口出现了。接口可以理解为某一个方面的抽象，可以是多对一的(多个类型实现一个接口)，这也是多态的体现。解决了上文一对一的问题。

怎么做？

 package main

import (
    "fmt"
)

// 定义一个接口
type People interface {
    ReturnName() string
}

// 定义一个结构体
type Student struct {
    Name string
}

// 定义结构体的一个方法。
// 突然发现这个方法同接口People的所有方法(就一个)，此时可直接认为结构体Student实现了接口People
func (s Student) ReturnName() string {
    return s.Name
}

func main() {
    wo := Student{Name:"布响丸辣"}

    var a People
    // 因为Students实现了接口所以直接赋值没问题
    // 如果没实现会报错：cannot use wo (type Student) as type People in assignment:Student does not implement People (missing ReturnName method)
    a = wo       
    name := a.ReturnName() 
    fmt.Println(name) // 输出"布响丸辣"
}

还有吗？

当然，前面三问仅仅是让我们对新知识点有了了解，但这还远远不够，这时候紧接着一问就来了，还有吗？当然有！关于GO接口相关的知识点还有以下几点：

空接口

空接口就是不包含任何方法的接口。正因为如此，所有的类型都实现了空接口。虽然空接口起不到任何作用，但是空接口在需要存储任何类型数值的时候非常有用。

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

类型断言

既然空接口可以存储任意类型，那么如何区分不同的类型？常用的有两种方法：Comma-ok断言、switch判断。

import (
    "fmt"
)

// 定义一个结构体
type Student struct {
    Name string
}

// 类型断言
func main() {
    Params := make([]interface{}, 3)
    Params[0] = 88                   // 整型
    Params[1] = "布响丸辣"         // 字符串
    Params[2] = Student{Name: "lsx"} // 自定义结构体类型

    // Comma-ok断言
    for index, v := range Params {
        if _, ok := v.(int); ok {
            fmt.Printf("Params[%d] 是int类型 \n", index)
        } else if _, ok := v.(string); ok {
            fmt.Printf("Params[%d] 是字符串类型\n", index)
        } else if _, ok := v.(Student); ok {
            fmt.Printf("Params[%d] 是自定义结构体类型\n", index)
        } else {
            fmt.Printf("list[%d] 未知类型\n", index)
        }
    }

    // switch判断
    for index, v := range Params {
        switch  value := v.(type) {
            case int:
            fmt.Printf("Params[%d] 是int类型, 值：%d \n", index,value)
            case string:
            fmt.Printf("Params[%d] 是字符串类型, 值：%s\n", index,value)
            case Student:
            fmt.Printf("Params[%d] 是Person类型, 值：%s\n", index,value)
            default:
            fmt.Printf("list[%d] 未知类型\n", index)
        } 

    }  
}

接口零值

package main

import (
    "fmt"
)

type People interface {  
    GetName() string
}

func main() {  
    var abc People
    if abc == nil {
        fmt.Println("abc is nil 类型")
    }
}

接口多实现

package main

import (
    "fmt"
)

type People interface {
    ReturnName() string
}

type Role interface {
    ReturnRole() string
}

type Student struct {
    Name string
}

func (s Student) ReturnName() string {
    return s.Name
}

func (s Student) ReturnRole() string {
    return "学生"
}

func main() {
    cbs := Student{Name: "布响丸辣"}

    var a People  // 定义a为People接口类型
    var b Role    // 定义b为Role接口类型

    a = cbs // 由于Student实现了People所有方法，所以接口实现成功，可直接赋值
    b = cbs // 由于Student实现了Role所有方法，所以接口实现成功，可直接赋值

    name := a.ReturnName()
    fmt.Println(name) // 输出"布响丸辣"

    role := b.ReturnRole()
    fmt.Println(role) // 输出"学生"
}

接口嵌套

package main

import (
    "fmt"
)

type People interface {
    ReturnName() string
}

type Role interface {
    People // 接口嵌套
    ReturnRole() string
}

type Student struct {
    Name string
}

func (s Student) ReturnName() string {
    return s.Name
}

func (s Student) ReturnRole() string {
    return "学生"
}

func main() {
    cbs := Student{Name: "布响丸辣"}

    var a Role
    a = cbs 
    name := a.ReturnName()
    fmt.Println(name)

    role := a.ReturnRole()
    fmt.Println(role) 
}