package main
import (
    "fmt"
)
//定义：Interface 是一组抽象方法(未具体实现的方法/仅包含方法名参数返回值的方法)的集合，
//有点像但又不同于其他编程语言中的 interface 。type interfaceName interface {//方法列表}  
//注意：1：interface 可以被任意对象实现，一个类型/对象也可以实现多个 interface，
//2：方法不能重载，如 eat() eat(s string) 不能同时存在  
//值：声明为 interface 类型的变量，可以存储任何实现了 interface 中所有方法的类型的变量(对
//象)。类的值类型传递方法会自动生成对应的引用类型传递方法，反之不成立  
//组合：将一个 interface1 嵌入到另一个 interface2 的声明中。其作用相当于把 interface1 的函数
//包含到 interface2 中，但是组合中不同有重复的方法。1.只要两个接口中的方法列表相同(与顺序
//无关)，即为相同的接口，可以相互赋值。2. interface1 的方法列表属于另一个 interface2 的方法
//列表的子集，interface2 可以赋值给 interface1，反之不成立(因为方法缺失)，interface2 中的方
//法会覆盖 interface1 中同名的方法。3.可以嵌入包中的 interface

type person struct {  
    name string  
    age  int  
}
func (p person) printMsg() {  
    fmt.Printf("I am %s, and my age is %d.\n", p.name, p.age)  
}
func (p person) eat(s string) {  
    fmt.Printf("%s is eating %s ...\n", p.name, s)  
}
func (p person) drink(s string) {  
    fmt.Printf("%s is drinking %s ...\n", p.name, s)  
}
type people interface {  
    printMsg()  
    peopleEat //组合  
    peopleDrink  
    //eat() //不能出现重复的方法  
}  
/**
//与上面等价
type people interface {  
    printMsg()  
    eat()  
    drink()  
}
*/
type peopleDrink interface {  
    drink(s string)  
}
type peopleEat interface {  
    eat(s string)  
}
type peopleEatDrink interface {  
    eat(s string)  
    drink(s string)  
}
//以上 person 类[型]就实现了 people/peopleDrink/peopleEat/peopleEatDrink interface 类型
type foodie struct {  
    name string  
}
func (f foodie) eat(s string) {  
    fmt.Printf("I am foodie, %s. My favorite food is the %s.\n", f.name, s)  
}
//foodie 类实现了 peopleEat interface 类型
func echoArray(a interface{}) {  
    b, _ := a.([]int) //这里是断言实现类型转换,如何不使用就会报错  
    for _, v := range b {  
        fmt.Println(v, " ")  
    }  
    return  
}
//任何类型都可以是interface
//要点：1interface关键字用来定义一个接口,2.Go没有implements、extends等关键字，
//3.实现一个接口的方法就是直接定义接口中的方法4.要实现多态，就要用指针或&object语法
func main() {  
    //定义一个people interface类型的变量p1
    var p1 people  
    p1 = person{"zhuihui", 40}  
    p1.printMsg()  
    p1.drink("orange juice")  
    //同一类可以属于多个 interface, 只要这个类实现了这个 interface中的方法
    var p2 peopleEat
    p2 = person{"zengzhihai", 40}
    p2.eat("bread")
    //不同类也可以实现同一个 interface
    var p3 peopleEat
    p3 = foodie{"ceshi"}
    p3.eat("noodle")
    //interface赋值
    p3 = p1 //p3中的方法会被p1中覆盖
    p3.eat("noodle")
    //interface查询
    //将子集peopleEat 转成people类型
    if p4, ok := p2.(people); ok {
        p4.drink("water")
        fmt.Println(p4)
    }
    //interface{}使得我们可以向函数传递任意类型的变量；
    //断言解决在使用interface{}的情况下，空接口类型向普通类型转换的类型转换问题；
    //普通类型之间的转换最好使用显式的类型转换，否者很可能导致严重的错误。
    a := []int{3, 5, 6}
    echoArray(a)
}
//空接口，无方法，即 interface{}，可以代表任何类型，有点类似于 java 中的 Object 类  
//可以作为任何形参和返回类型，mixed