go语言基础之接口，空接口，类型断言

接口
在Go语言中的接口是一种类型，一种抽象类型，interface是一组方法（method）的集合，接口就像是定义了一个协议，一个规则，，只要一台机器有洗衣服和甩干功能我们就叫他是洗衣机，不关心属性，只关心行为
接口实现的条件
一个对象只要全部实现了接口中的方法，那么就实现了这个接口，换句话说，接口就是一个需要实现的方法列表
接口类型变量
接口类型可以存储所有实现了该接口的实例，
类型与接口的关系
一个类型可以同时实现多个接口，这些接口之间是独立的
接口的值
接口的存储分为两部分，一部分是具体类型，一部分是具体类型的值，这两部分分别称为，动态类型和动态值。

package main

import "fmt"
//定义一个接口
type pp interface {
    
    
    run()
}

type person struct {
    
    
    name string
    age  int
}
func (p *person) run() {
    
    
    fmt.Println("跑")
}
type print struct {
    
    
    name string
}
func (p print) run() {
    
    
    fmt.Println("跑不了")
}
func main() {
    
    
    p := &person{
    
    
        "dlq",
        21,
    }
    //初始化接口
    pp1 := pp(p)
    pp1.run()
    p1 := print{
    
    
        "zkj",
    }
    //接口类型可以存储所有类型的实力
    //当类型下的函数，为指针就守着，那么存到接口中的也应该为指针类型
    pp2 := pp(p1)
    pp2.run()
}

接口的嵌套，类型与接口的关系，空接口，类型断言

package main

import "fmt"
type pp1 interface {
    
    
    run()
}
type pp2 interface {
    
    
    move()
}
//接口的嵌套，那么这个切口就拥有所有嵌套的接口中的方法
type pp3 interface {
    
    
    pp1
    pp2
}
type person struct {
    
    
    name string
    age  int
}
func (p *person) run() {
    
    
    fmt.Println("run")
}
func (p *person) move() {
    
    
    fmt.Println("move")
}
//一个类型可以同时实现多个接口，接口之间是独立的
func main() {
    
    
    p := &person{
    
    }
    pp1 := pp1(p)
    pp2 := pp2(p)
    pp1.run()
    pp2.move()
    pp3 := pp3(p)
    pp3.move()
    //空接口
    mapp := map[string]interface{
    
    }{
    
    
        "name":  "dlq",
        "age":   12,
        "hobby": []string{
    
    "吃", "喝", "玩", "乐"},
    }
    fmt.Println(mapp)
    x := mapp["hobby"]
    //类型断言，判断一个变量是不是你想要的值
    v, ok := x.([]string)
    if !ok {
    
    
        fmt.Println("这个变量不是[]string类型")
    }
    fmt.Println(v)
}