golang Interface类型详解

   简单的说，接口就是一组方法签名的集合。我们使用一个接口来识别一个对象能够进行的操作。type Human struc
4000
t {
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{}，实际上函数是在说“兄弟，我接受任何数据”。如果一个函数返回一个空接口类型，那么函数再说“我也不确定返回什么，你只要知道我一定返回一个值就好了”。