go中的interface

1、interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口；

2、interface可以被任意的对象实现，一个对象可以实现任意多个interface；

3、任意的类型都实现了空interface(interface{})，也就是包含0个method的interface；

4、对于一个interface的变量，该变量可以存储实现这个interface的任意类型的对象：

5、一个包含interface类型元素的slice，这个slice可以被赋予实现了该interface的任意结构的对象

package main
import "fmt"

type Human struct {
	name string
	age int
	phone string
}

type Student struct {
	Human
	school string
	loan float32
}

type Employee struct {
	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...", lyrics)
}

//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)
}

// Interface Men被Human,Student和Employee实现
// 因为这三个类型都实现了这两个方法
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{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}

	var i Men //定义Men类型的变量i

	i = mike //i能存储Student
	fmt.Println("This is Mike, a Student:")
	i.SayHi()
	i.Sing("November rain")

	i = Tom //i也能存储Employee
	fmt.Println("This is Tom, an Employee:")
	i.SayHi()
	i.Sing("Born to be wild")

	x := make([]Men, 3)
	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 Tom, I work at Things Ltd.. Call me on 222-444-XXX
La la la la... Born to be wild
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

6、空interface(interface{})不包含任何的method，所以所有的类型都实现了空interface。空interface可以存储任意类型的数值：

var a interface{}
var i int = 5
s := "Hello world"
// a可以存储任意类型的数值
a = i
a = s

7、一个函数把interface{}作为参数，那么该函数可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。 

8、方法集

形式1

Values	Methods Receivers
T	(t  T)
*T	(t  T) 或者 (t  *T)

形式二

Methods Receivers	Values
(t  T)	T 或者 *T
(t  *T)	*T

 

type notifier interface {notify()}
type user struct {
	name string
	email string
}
func (u *user) notify(){ fmt.Printf("Sending user email to %s<%s>\n", u.name, u.email) }
func main(){
	u := user{"Bill", "bill@email.com"}
	sendNotification(&u)
}
func sendNotification(n notifier){ n.notify() }

注意 sendNotification函数的参数类型为notifier接口类型，之后该函数调用notify方法。如果使用指针接收者(u *user)来实现一个接口，那么只有指向那个类型的指针(&u)才能实现对应的接口。如果使用值接收者来实现一个接口，那么那个类型的值和指针都能够实现对应的接口。