简单的说，interface 是一组 method 的组合，我们通过 interface 来定义对象的一组行为。
我们前面一章最后一个例子中 Student 和 Employee 都能 Sayhi，虽然他们的内部实现不一
样，但是那不重要，重要的是他们都能 say hi
让我们来继续做更多的扩展，Student 和 Employee 实现另一个方法 Sing，然后 Student 实
现方法 BorrowMoney 而 Employee 实现 SpendSalary。
这样 Student 实现了三个方法：Sayhi、Sing、BorrowMoney；而 Employee 实现了
Sayhi、Sing、SpendSalary。
上面这些方法的组合称为 interface(被对象 Student 和 Employee 实现)。例如 Student 和
Employee 都实现了 interface：Sayhi 和 Sing，也就是这两个对象是该 interface 类型。而
Employee 没有实现这个 interface：Sayhi、Sing 和 BorrowMoney，因为 Employee 没有实
现 BorrowMoney 这个方法。
interface 类型
interface 类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实
现了此接口。详细的语法参考下面这个例子
type Human struct {
name string
age int
phone string
}
type Student struct {
Human //匿名字段 Human
school string
loan float32
}
type Employee struct {
Human //匿名字段 Human
company string
money float32
}
//Human 对象实现 Sayhi 方法
func (h *Human) SayHi() {
fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
// Human 对象实现 Sing 方法
func (h *Human) Sing(lyrics string) {
fmt.Println("La la, la la la, la la la la la...", lyrics)
}
//Human 对象实现 Guzzle 方法
func (h *Human) Guzzle(beerStein string) {
fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
}
// Employee 重载 Human 的 Sayhi 方法
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.
}
//Student 实现 BorrowMoney 方法
func (s *Student) BorrowMoney(amount float32) {
s.loan += amount // (again and again and...)
}
//Employee 实现 SpendSalary 方法
func (e *Employee) SpendSalary(amount float32) {
e.money -= amount // More vodka please!!! Get me through the day!
}
// 定义 interface
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
interface 被 Human、Student 和 Employee 实现。同理，一个对象可以实现任意多个
interface，例如上面的 Student 实现了 Men 和 YonggChap 两个 interface。
最后，任意的类型都实现了空 interface(我们这样定义：interface{})，也就是包含 0 个
method 的 interface。
