golang Interface类型详解_golang interface类型

   简单的说，接口就是一组方法签名的集合。我们使用一个接口来识别一个对象能够进行的操作。

type Human struct {
    name string
    age int
    phone string
}
 
type Student struct {
    Human //an anonymous field of type Human
    school string
    loan float32
}
 
type Employee struct {
    Human //an anonymous field of type Human
    company string
    money float32
}
 
// A human likes to stay... err... *say* hi
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
// A human can sing a song, preferrably to a familiar tune!
func (h *Human) Sing(lyrics string) {
    fmt.Println("La la, la la la, la la la la la...", lyrics)
}
 
// A Human man likes to guzzle his beer!
func (h *Human) Guzzle(beerStein string) {
    fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
}
 
// Employee's method for saying hi overrides a normal Human's one
func (e *Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
        e.company, e.phone) //Yes you can split into 2 lines here.
}
 
// A Student borrows some money
func (s *Student) BorrowMoney(amount float32) {
    loan += amount // (again and again and...)
}
 
// An Employee spends some of his salary
func (e *Employee) SpendSalary(amount float32) {
    e.money -= amount // More vodka please!!! Get me through the day!
}
 
// INTERFACES
type Men interface {
    SayHi()
    Sing(lyrics string)
    Guzzle(beerStein string)
}
 
type YoungChap interface {
    SayHi()
    Sing(song string)
    BorrowMoney(amount float32)
}
 
type ElderlyGent interface {
    SayHi()
    Sing(song string)
    SpendSalary(amount float32)
}

    一个接口可以被任意数量的类型满足，并且，一个类型可以实现任意数量的接口。最后需要说明的是，每个类型都实现了一个空接口interface{}。

   因为接口也是一种类型，你可以声明一个接口变量，这个变量能够存储任何实现该接口的对象类型。也就是说，如果我们声明了Men类型的接口变量m，那么这个变量就可以存储Student和Employee类型的对象，还有Human类型。这是因为它们都实现了Men接口声明的方法签名。

   如果m能够存储不同数据类型的值，我们可以轻松实现一个Men切片，该切片包含不同的数据类型的实例。

package main
import "fmt"
 
type Human struct {
    name string
    age int
    phone string
}
 
type Student struct {
    Human //an anonymous field of type Human
    school string
    loan float32
}
 
type Employee struct {
    Human //an anonymous field of type Human
    company string
    money float32
}
 
//A human method to say hi
func (h Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
 
//A human can sing a song
func (h Human) Sing(lyrics string) {
    fmt.Println("La la la la...", lyrics)
}
 
//Employee's method overrides Human's one
func (e Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
        e.company, e.phone) //Yes you can split into 2 lines here.
}
 
// Interface Men is implemented by Human, Student and Employee
// because it contains methods implemented by them.
type Men interface {
    SayHi()
    Sing(lyrics string)
}
 
func main() {
    mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
    Tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
 
    //a variable of the interface type Men
    var i Men
 
    //i can store a Student
    i = mike
    fmt.Println("This is Mike, a Student:")
    i.SayHi()
    i.Sing("November rain")
 
    //i can store an Employee too
    i = Tom
    fmt.Println("This is Tom, an Employee:")
    i.SayHi()
    i.Sing("Born to be wild")
 
    //a slice of Men
    fmt.Println("Let's use a slice of Men and see what happens")
    x := make([]Men, 3)
    //These elements are of different types that satisfy the Men interface
    x[0], x[1], x[2] = paul, sam, mike
 
    for _, value := range x{
        value.SayHi()
    }
}

   输出结果是：

This is Mike, a Student:
Hi, I am Mike you can call me on 222-222-XXX
La la la la... November rain
This is Tom, an Employee:
Hi, I am Sam, I work at Things Ltd.. Call me on 444-222-XXX
La la la la... Born to be wild
Let’s use a slice of Men and see what happens
Hi, I am Paul you can call me on 111-222-XXX
Hi, I am Sam, I work at Golang Inc.. Call me on 444-222-XXX
Hi, I am Mike you can call me on 222-222-XXX

   接口类型是一组抽象的方法集，它本身不实现方法或精确描述数据结构和方法的实现方式。值得注意的是这些数据类型没有提及任何的关于接口的信息，方法签名的实现部分也没有包含给定的接口类型的信息。

   同样的，一个接口类型也不会关心到底是什么数据类型实现了它自身。接口类型的本质就是如果一个数据类型实现了自身的方法集，那么该接口类型变量就能够引用该数据类型的值。

   空接口类型interface{}一个方法签名也不包含，所以所有的数据类型都实现了该方法。空接口类型在描述一个对象实例的行为上力不从心，但是当我们需要存储任意数据类型的实例的时候，空接口类型的使用使得我们得心应手。

   如果一个函数的参数包括空接口类型interface{}，实际上函数是在说“兄弟，我接受任何数据”。如果一个函数返回一个空接口类型，那么函数再说“我也不确定返回什么，你只要知道我一定返回一个值就好了”。

参考：

https://www.yuque.com/docs/share/d25a5102-1a53-4640-b26d-5ed23c4977c1