Go接口

@爱耍流氓的唐僧  February 20, 2021

Go语言中接口(interface)是一种类型,一种抽象的,特殊的类型,它规定了变量有哪些方法。

Go语言提倡面向接口编程。
每个接口由数个方法组成,接口的定义格式如下:

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

其中:
接口名:使用type将接口定义为自定义的类型名。Go语言的接口在命名时,一般会在单词后面添加er,如有写操作的接口叫Writer,有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。
方法名:当方法名首字母是大写且这个接口类型名首字母也是大写时,这个方法可以被接口所在的包(package)之外的代码访问。
参数列表、返回值列表:参数列表和返回值列表中的参数变量名可以省略。
举个例子:

type Writer interface{
    Write([]byte) error
}

接口用来给变量、参数、返回值设置类型。(接口也是一种数据类型

接口的实现
一个对象(变量)只要全部实现了接口中所有的方法,那么就实现了这个接口(一个结构体类型的实现了某个接口,可以说这个变量的具体类型是某种结构体类型,抽象类型就是某类型的接口)。换句话说,接口就是一个需要实现的方法列表。

示例:

package main

type animal interface{
    move()
    eat([x] string)
}

type cat struct{
    name string
    feet int8
}

type chicken struct{
    feet int8
}

func (c chicken) move(){
    fmt.Println("鸡动......")
}

func (c chicken) eat(food string){
    fmt.Printf("吃鸡饲料%s\n......",food)
}

func (c cat) move(){
    fmt.Println("走猫步......")
}

func (c act) eat(food string){
    fmt.Printf("猫吃鱼%s\n......",food)
}
func main(){
    var a1 animal//定义一个接口类型的变量
    bc :=cat{ //定义一个cat类型的变量的bc
        name:"淘气",
        feet:4,
    }
    a1 = bc //实现接口类型的方法必须参数返回值必须一样
    a1.eat("小黄鱼")//a1
}

微信图片_20210222165904.png
interface.png

接口类型变量
实现了接口的所有方法就实现了这个接口,实现了接口就可以当成这个接口类型的变量。
接口类型的万能变量,可以保存所有实现这个接口类型的值,通常接口作为函数的参数出现。

那实现了接口有什么用呢?
接口类型变量能够存储所有实现了该接口的实例。 例如上面的示例中,anaimal类型的变量能够存储chicken和cat类型的变量。

值接收者和指针接收者实现接口的区别
使用值接收者实现接口和使用指针接收者实现接口有什么区别呢?接下来我们通过一个例子看一下其中的区别。

我们有一个Mover接口和一个dog结构体。

type Mover interface {
    move()
}

type dog struct {}

使用值接收者实现接口的所有方法

func (d dog) move() {
    fmt.Println("狗会动")
}

此时实现接口的是dog类型:

func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x可以接收dog类型
    fmt.Println(x)      //dog{}
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
    fmt.Println(x)      //&dog{}
    x.move()
}

从上面的代码中我们可以发现,使用值接收者实现接口之后,不管是dog结构体还是结构体指针dog类型的变量都可以赋值给该接口变量。因为Go语言中有对指针类型变量求值的语法糖,dog指针fugui内部会自动求值fugui。

指针接收者实现接口
同样的代码我们再来测试一下使用指针接收者有什么区别:

func (d *dog) move() {
    fmt.Println("狗会动")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x不可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
}

此时实现Mover接口的是dog类型,所以不能给x传入dog类型的wangcai,此时x只能存储dog类型的值。

使用值接收者实现接口和使用指针接收者实现接口的区别?
**使用值接收者实现接口,结构体类型和结构体指针类型的变量都能存
使用指针接收者实现接口只能存结构体指针变量**

接口和类型的关系(接口类似于一种协议)
多个类型可以实现同一个接口
一个类型可以实现多个接口
接口还可以嵌套

// Sayer 接口
type Sayer interface {
    say()
}

// Mover 接口
type Mover interface {
    move()
}

// 接口嵌套
type animal interface {
    Sayer
    Mover
}

空接口的定义
空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口(interface{})。
空接口类型的变量可以存储任意类型的变量。

func main() {
    // 定义一个空接口x
    var x interface{}
    s := "Hello 沙河"
    x = s
    fmt.Printf("type:%T value:%v\n", x, x)
    i := 100
    x = i
    fmt.Printf("type:%T value:%v\n", x, x)
    b := true
    x = b
    fmt.Printf("type:%T value:%v\n", x, x)
}

空接口的应用
空接口作为函数的参数
使用空接口实现可以接收任意类型的函数参数。

// 空接口作为函数参数
func show(a interface{}) {
    fmt.Printf("type:%T value:%v\n", a, a)
}

空接口作为map的值
使用空接口实现可以保存任意值的字典。

// 空接口作为map值
var studentInfo = make(map[string]interface{})
studentInfo["name"] = "沙河娜扎"
studentInfo["age"] = 18
studentInfo["married"] = false
fmt.Println(studentInfo)

类型断言
空接口可以存储任意类型的值,那我们如何获取其存储的具体数据呢?
想要判断空接口中的值这个时候就可以使用类型断言,其语法格式:

x.(T)

其中:

x:表示类型为interface{}的变量
T:表示断言x可能是的类型。
该语法返回两个参数,第一个参数是x转化为T类型后的变量,第二个值是一个布尔值,若为true则表示断言成功,为false则表示断言失败。

举个例子:

func main() {
    var x interface{}
    x = "Hello 沙河"
    v, ok := x.(string)
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("类型断言失败")
    }
}

上面的示例中如果要断言多次就需要写多个if判断,这个时候我们可以使用switch语句来实现:

func justifyType(x interface{}) {
    switch v := x.(type) {
    case string:
        fmt.Printf("x is a string,value is %v\n", v)
    case int:
        fmt.Printf("x is a int is %v\n", v)
    case bool:
        fmt.Printf("x is a bool is %v\n", v)
    default:
        fmt.Println("unsupport type!")
    }
}

因为空接口可以存储任意类型值的特点,所以空接口在Go语言中的使用十分广泛。

关于接口需要注意的是,只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口,那样只会增加不必要的抽象,导致不必要的运行时损耗。


添加新评论