接口

接口是一种类型,是一种特殊的类型,它规定了变量有哪些方法
在编程中会遇到以下场景
我不关心一个变量是什么类型,我只关心能调用它的

package main

import "fmt"

type da interface {
    jiao()
}

type dog struct {
    sy string
}
type cat struct {
    js string
}

func (c dog) jiao() {
    fmt.Println(c.sy)
}
func (c cat) jiao() {
    fmt.Println(c.js)
}
func daJiao(d da) {
    d.jiao()
}

func main() {
    var d = dog{
        sy: "汪汪汪",
    }
    var c = cat{
        js: "喵",
    }
    daJiao(c) //喵
    daJiao(d) //汪汪汪
    var ss da
    fmt.Printf("%T\n", ss) //<nil>
    ss = d
    fmt.Printf("%T\n", ss) //main.dog
    fmt.Println(ss)        //汪汪汪
    ss = c
    fmt.Printf("%T\n", ss) //main.cat
}

接口的定语

type 接口名 interface{
    方法名1(参数1,参数2)(返回值1,返回值2)
    方法名2(参数1,参数2)(返回值1,返回值2)
}

接口的实现

一个变量如果实现了接口中规定的所有方法,那么这个变量就实现了这个接口,可以称为这个接口的类型的变量

接口存储数据的时候分为俩部分,一部分是类型,一部分是类型的值

所以接口类型的变量可以存任意类型的值

值接收者和指针接收者实现接口的区别

package main

import "fmt"

type da interface {
    jiao()
}

type cat struct {
    js string
}

func (c *cat) jiao() { //如果这里传入的是指针
    fmt.Println(c.js, "叫")
}
func (c cat) zou() {
    fmt.Println(c.js, "走")
}
func daJiao(d da) {
    d.jiao()
}

func main() {
    var dongwu da
    c1 := cat{"喵"}
    c2 := cat{"喵的"}
    dongwu = &c1 //那么这里也要传入地址
    dongwu = &c2
    fmt.Println(dongwu)
}

区别:

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

指针接收者实现,接口只能存结构体指针类型的变量

同一个结构体可以实现多个接口,接口还可以嵌套

空接口

空接口没有必要起名字,通常定义成下面的格式

type interface{}//空接口

所有类型都实现了空接口,也就是任意类型的变量都能保存到空接口中

当保存的值不值得是什么类型的时候,就可以写一个空接口

package main

import "fmt"

//空接口作为函数的参数
func show(a interface{}) {
    fmt.Printf("%T", a)
}

//interface是关键字
//interface{}:空接口类型
func main() {
    var m1 map[string]interface{}
    m1 = make(map[string]interface{}, 16)
    m1["name"] = "zl"
    m1["age"] = 9000
    m1["merried"] = true
    m1["hoby"] = [...]string{"唱", "跳", "rap"}
    fmt.Println(m1) //map[age:9000 hoby:[唱 跳 rap] merried:true name:zl]
    show(m1)        //map[string]interface {}
}