Interface is a group of method signatures, continuin with the example before, if Student realize three methods:

SayHi,Sing,BorrowMoney,while Employee realize SayHi,Sing,SpendSalary, the combination of those methods is defined as interface.

Here SayHi and Sing are realized by both structs, so those two structs belong to this interface(the combination of SayHi and Sing).

Simply speaking, the interface defines a group of methods, if one object realize all methods of this interface, then this object realize this 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對象實現(xiàn)Sayhi方法func (h *Human) SayHi() {    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)}// Human對象實現(xiàn)Sing方法func (h *Human) Sing(lyrics string) {    fmt.Println("La la, la la la, la la la la la...", lyrics)}//Human對象實現(xiàn)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) //此句可以分成多行}//Student實現(xiàn)BorrowMoney方法func (s *Student) BorrowMoney(amount float32) {    s.loan += amount // (again and again and...)}//Employee實現(xiàn)SpendSalary方法func (e *Employee) SpendSalary(amount float32) {    e.money -= amount // More vodka please!!! Get me through the day!}// 定義interfacetype 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)}

Men interface could be realized by Human, Student and Employee, one interface could be realizedd by a number of structs. Similarily, one struct could also realize more than one interface, Student realizes Men and YoungChap.

All types realize empty interface(without method):

interface{}        //empty interface

fmt.Println()

An constantly used output function, all types could be used as input which will be output as its initial form.

Here is how it is realized in the souce code:

type Stringer interface(){    String() string}

String is the pre-defined interface object, String() is a method whose return type is string, which means all types which could realize String() method can be disposed as the input and thus call fmt.Pringln().

So, if our struct could realize the so-called String() method, then our struct could also be compatible with fmt.Println().

package mainimport (    "fmt"    "strconv")type Human struct {    name string    age int    phone string}// 通過這個方法 Human 實現(xiàn)了 fmt.Stringerfunc (h Human) String() string {    return "?"+h.name+" - "+strconv.Itoa(h.age)+" years -  ? " +h.phone+"?"}func main() {    Bob := Human{"Bob", 39, "000-7777-XXX"}    fmt.Println("This Human is : ", Bob)}

Here our manully defined struct Human overloaded the method String(), so when we call the fmt.Println(), the customized output could be surpported.

The value of interface

So, what should we put into one interface? if we define a variable of interface, then this variable could store any object which has realized this interface.For the example above, if we define a variable m,then m can sore Human,Student,Employee.

package mainimport "fmt"type Human struct{    name string    age int    phone string}type Student struct{    Human    age int    phone string}type Employee struct{    Human    //anaonymous segment    company    loan float32}func (h Human)SayHi(){    fmt.Println("I am a human")}func (s Student)SayHi(){    fmt.Println("I am a studnet")}func (e Employee)SayHi(){    fmt.Println("I am a employee")}type Men interface{    SayHi()}func main(){    mike := Student{Human{"Mike",25,"222-222"},"MIT",0}    same := Employee{Human{"Sam",36,"333-333"},"Golang Inc.",1000}    var i Men    //defien a interface    i = mike    //i can store student    i.SayHi()    i = tom    i.SayHi()}

Empty interface

All types realized the empty interface.

var a interface{}var i int = 5s := "Hello world"http://a can store any typesa = ia = s

Comma-ok mechanisim(a little confusing)

We can overload the specific function for one type so as to make it suitable for some interfaces, but how can we know which kinds of type can realize a specific interface?

To judge a parameter's type, here is a syntax for this:

value, ok = element.(T)

element is the interface , T is the type which we want to know whether it corresponds to element,

Interface insertion

Interface1 could be a insertion of interface2 so that we do not have to write the same interfaces again and again.

type Interface interface {    sort.Interface //嵌入字段sort.Interface    Push(x interface{}) //a Push method to push elements into the heap    Pop() interface{} //a Pop elements that pops elements from the heap}

Interface could include all the interface of sort:

type Interface interface {    // Len is the number of elements in the collection.    Len() int    // Less returns whether the element with index i should sort    // before the element with index j.    Less(i, j int) bool    // Swap swaps the elements with indexes i and j.    Swap(i, j int)}

An other example of interface is:

// io.ReadWritertype ReadWriter interface {    Reader    Writer}

ReadWrite interface is simply the superposition of interface Reader and Write.

Reflection

1.get the reflect type of i first

t := reflect.TypeOf(i)    //得到類型的元數(shù)據(jù),通過t我們能獲取類型定義里面的所有元素v := reflect.ValueOf(i)   //得到實際的值牵咙，通過v我們獲取存儲在里面的值嵌洼，還可以去改變值

1. get the corresponding value

tag := t.Elem().Field(0).Tag  //獲取定義在struct里面的標(biāo)簽name := v.Elem().Field(0).String()  //獲取存儲在第一個字段里面的值

1. get the type and value of i

var x float64 = 3.4v := reflect.ValueOf(x)fmt.Println("type:", v.Type())fmt.Println("kind is float64:", v.Kind() == reflect.Float64)fmt.Println("value:", v.Float())

Here is the result:

type: float64kind is float64: truevalue: 3.4

If you execute the following code:

v.SetFloat(7.1)

the program will report a mestery error:

panic: reflect: reflect.Value.SetInt using unaddressable value

Here when we set the value of v, the passed input x is the copy of the original one, changing it is meaningless and illegal, this is the meaning of "unaddressable".

Similarly, passing the point of x is OK if you intend to change the value of x

var x float64 = 3.4p := reflect.ValueOf(&x)v := p.Elem()v.SetFloat(7.1)

Changing the address of x so as to change the value of it is workable.