• 接口
• 空接口
• 接口嵌套
• 接口断言

接口

    * 接口，方法的集合，interface来定义

//定义接口 interface ,方法的集合
type USB interface{
    input() //输入方法
    output() //输出方法
}
//结构体
type mouse struct{
    name string
}
type keyBoard struct{
    name string
}
//结构体实现了接口中的所以方法代表实现了这个接口，否则不算实现接口
func (m mouse) output(){
    fmt.Println("output")
}
func (m mouse) input(){
    fmt.Println("input")
}
func (k keyBoard) output(){
    fmt.Println(k.name,"output")
}
func (k keyBoard) input(){
    fmt.Println(k.name,"input")
}
//接口调用测试
func test(u USB){
    u.input()
    u.output()
}
func main() {
    m:=mouse{name: "雷蛇"}
    test(m)
    k:=keyBoard{name: "罗技"}
    test(k)
}

空接口

    * 不包含任何方法，所有结构体默认实现了空接口，空接口可以存储任何类型

//定义空接口
type A interface{}
//结构体
type dog struct{
    name string
}
type cat struct{
    name string
}
//测试接口
func test(a A){
    fmt.Println(a)
}
func main() {
    //空接口可以接收任意类型
    var a A=dog{name: "a"}
    var b A=cat{name: "b"}
    var c A=1
    var d A="qwe"
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}

接口嵌套

    * 接口中嵌套接口

//接口
type A interface{
    test1()
}
type B interface{
    test2()
}
type C interface{
    //导入A、B接口
    A
    B
    test3()
}
//结构体,实现C接口
type dog struct{
}
func (d dog) test1(){
    fmt.Println("test1")
}   
func (d dog) test2(){
    fmt.Println("test2")
}
func(d dog) test3(){
    fmt.Println("test3")
}
func main() {
    //dog有4个形态：dog,A,B,C
    var d dog =dog{}
    d.test1()
    d.test2()
    d.test3()
}

接口断言

    * 检查接口类型的变量是不是符合期望值
    * 被断言的对象必须是接口类型
    * 通过switch i .(type) case 来判断

//接口
type A interface{}  
func testA(i interface{}){
        //switct i.(type) 断言
    switch i.(type){
    case string:
        fmt.Println("string")
    case int:
        fmt.Println("int")
    case A:
        fmt.Println("A")
    case nil:
        fmt.Println("nil")
    case interface{}:
        fmt.Println("interface{}")
    default:
        fmt.Println("未知")
    }
}
func main() {
    testA("string")
    testA(1)
    var a A
    var a1 A=1
    testA(a)
    testA(a1)
}