From：https://www.cnblogs.com/Mike-zh/p/3787679.html

简单地说 Interface是一组Method的组合，可以通过Interface来定义对象的一组行为。

如果某个对象实现了某个接口的所有方法，就表示它实现了该借口，无需显式地在该类型上添加接口说明。

Interface是一个方法的集合，它里面没有其他类型变量，而且Method只用定义原型 不用实现

①接口定义

1.命名时习惯以"er"结尾，如Printer Reader Writer

2.一个Interface的Method不宜过多，一般0~3个

3.一个Interface可以被任意的对象事项；相应地，一个对象也可以实现多个Interface

示例：

type Peoplestruct{

    Name string}

type Student struct{

    People

    School string}

type Teacher struct{

    People

    Department string}

func (p People) SayHi(){}

func (s Student) SayHi(){}

func (t Teacher) SayHi(){}

func (s Student) Study(){}//根据struct的方法提取接口 从而使struct自动实现了该接口type Speakerinterface{

    SayHi()

}

type Learner interface{

    SayHi()

    Study()

}

上面的例子中，Speaker接口被对象People，Teacher，Student实现；而Student同时实现了接口Speaker和Learner。

接口组合：

type SpeakLearnerinterface {

    Speaker

    Learner

}//组合后使得SpeakLearner具有Speaker和Learner的功能

空接口：

任何类型都实现了空接口,相当于Java中的Object类

func test(ainterface{}){}//该方法可以接受任意类型（int rune float32 struct...）的参数

②接口执行机制和接口赋值

首先介绍一种Go语言带接收者(Receiver)的函数机制（下面的两种情况执行结果一样，涉及到struct成员值改变时仍然一样）

情况1：

package main

import (

    "fmt")

type People struct {

    Name string}

func (p People) SayHi(){ //此处的Receiver是strcutfmt.Println("hello, this is", p.Name)

}

func (p *People) Study(){//此处的Receiver是****structfmt.Printf("%s is studying\n", p.Name)

}

type SpeakLearner interface {

    SayHi()

    Study()

}

func main() {

    people := People{"zhangsan"}//这里的people为People类型    people.SayHi()

    people.Study()

}

情况2：

func main() {

    people := &People{"zhangsan"}//这里的people为**People类型，即指针    people.SayHi()

    people.Study()

}

通过上面的例子可以看出Receiver为People和*People的函数均可被People或者*People两种类型调用，接下来借可能有在调用过程中People与*People之间的转换问题

看下面的例子：

package main

import (

    "fmt")

type Example struct{

    Integer1 int    Integer2 int}

func (e Example) Assign(num1 int, num2int) {

    e.Integer1, e.Integer2 = num1, num2

}

func (e *Example) Add(num1int, num2int) {

    e.Integer1 +=num1

    e.Integer2 +=num2

}

func main(){

    vare1 Example = Example{3,4}

    e1.Assign(1,1)

    fmt.Println(e1)

    e1.Add(1,1)

    fmt.Println(e1)

    vare2 *Example = &Example{3,4}

    e2.Assign(1,1)

    fmt.Println(e2)

    e2.Add(1,1)

    fmt.Println(e2)

}

以上程序的执行结果为：

{3,4}

{4,5}&{3,4}&{4,5}

可以看出实际执行的过程按函数定义前的Receiver类型执行。

对于接口的执行机制：

1.T仅拥有属于T类型的方法集，而*T则同时拥有（T+*T）方法集

2.基于T实现方法，表示同时实现了interface和interface（*T）接口

3.基于*T实现方法，那就只能是对interface（*T）实现接口

type Integerintfunc (a Integer) Less(b Integer) bool {

    returna < b

}

func (a *Integer) Add(b Integer) {

    *a += b

}

相应地，我们定义接口LessAdder，如下：

type LessAdder interface {

    Less(b Integer) bool    Add(b Integer)

}

现在有个问题：假设我们定义一个Integer类型的对象实例，怎么将其赋值给LessAdder接口呢？

应该用下面的语句(1)，还是语句(2)呢？vara Integer =1varb LessAdder = &a  ... (1)varb LessAdder = a  ... (2)

答案是应该用语句(1)。原因在于，Go语言可以根据下面的函数：

func (a Integer) Less(b Integer) bool 

即自动生成一个新的Less()方法：

func (a *Integer) Less(b Integer)bool {

    return(*a).Less(b)

}

这样，类型*Integer就既存在Less()方法，也存在Add()方法，满足LessAdder接口。

而从另一方面来说，根据

func (a *Integer) Add(b Integer)

这个函数无法自动生成以下这个成员方法：

func (a Integer) Add(b Integer) {

    (&a).Add(b)

}

因为(&a).Add()改变的只是函数参数a，对外部实际要操作的对象并无影响，这不符合用

户的预期。所以，Go语言不会自动为其生成该函数。

因此，类型Integer只存在Less()方法，缺少Add()方法，不满足LessAdder接口，故此上面的语句(2)不能赋值。

接口赋值举例：

package main

import(

    "fmt")//定义对象People、Teacher和Studenttype Peoplestruct {

    Name string}

type Teacher struct{

    People

    Department string}

type Student struct{

    People

    School string}//对象方法实现func (p People) SayHi() {

    fmt.Printf("Hi, I'm %s. Nice to meet you!\n",p.Name)

}

func (t Teacher) SayHi(){

    fmt.Printf("Hi, my name is %s. I'm working in %s .\n", t.Name, t.Department)

}

func (s Student) SayHi() {

    fmt.Printf("Hi, my name is %s. I'm studying in %s.\n", s.Name, s.School)

}

func (s Student) Study() {

    fmt.Printf("I'm learning Golang in %s.\n", s.School)

}//定义接口Speaker和Learnertype Speakerinterface{

    SayHi()

}

type Learner interface{

    SayHi()

    Study()

}

func main() {

    people := People{"张三"}

    teacher := Teacher{People{"郑智"},"Computer Science"}

    student := Student{People{"李明"},"Yale University"}

    varisSpeaker//定义Speaker接口类型的变量is= people//is能存储Peopleis.SayHi()

    is= teacher//is能存储Teacheris.SayHi()

    is= student

    is.SayHi()//is能存储Studentvar il Learner

    il = student//Learner类型接口的变量能存储Student    il.Study()

}

执行结果为：

Hi, I'm 张三. Nice to meet you!Hi, my nameis郑智. I'm working in Computer Science .Hi, my nameis李明. I'm studying in Yale University.I'm learning Golang in Yale University.

通过这个例子可以 看到（如同Java等语言）接口机制在多态和创建可扩展可重用的代码时的重要作用

③匿名字段和接口转换

若果接口类型S内部嵌入了接口类型T（匿名），则接口匿名字段方法集规则如下：

1.如果S嵌入匿名类型T，则S方法集包含T方法集。

2.如果S嵌入匿名类型*T，则S方法集包含*T方法集(包括Riceiver为T和*T的方法)。

3.如果S嵌入匿名类型T或*T，则*S方法集包含*T方法集（包括Riceiver为T和*T的方法）。（重要）

例如：

package main

import(

    "fmt"   

)

type People struct {

    Name string}

type S1 struct{

    People              //S1类型嵌入匿名PeopleDepartmentstring}

type S2 struct{

    *People//S2类型嵌入匿名*PeopleDepartmentstring}

func (p People) Say1() {

    fmt.Printf("Hi, I'm %s. Say1111\n",p.Name)

}

func (p *People) Say2() {

    fmt.Printf("Hi, I'm %s. Say2222\n",p.Name)

}

type Speaker interface{

    Say1()

    Say2()

}

func main() {

    people := People{"张三"}

    s1 := S1{People{"郑智"},"Computer Science"}

    s2 := S2{&People{"李明"},"Math"}

    varis Speaker 

    is= &people//*People实现了Speaker接口is.Say1()

    is.Say2()

    //is = s1  //S1类型嵌入匿名People  不存在Say2()方法 因而未实现Speaker接口

            //错误提示： cannot use s1 (type S1) as type Speaker in assignment:

            //S1 does not implement Speaker (Say2 method has pointer receiver)is= s2//S2类型嵌入匿名*People  因而(p People) Say1()和(p *People) Say2()方法都有 实现了Speaker接口is.Say1()

    is.Say2()

    is= &s1//S1类型嵌入匿名People  *S1 实现了Speaker接口is.Say1()

    is.Say2()

    is= &s2//S2类型嵌入匿名*People  *S2 实现了Speaker接口is.Say1()

    is.Say2()

}

 执行结果为：

Hi, I'm 张三. Say1111Hi, I'm 张三. Say2222Hi, I'm 李明. Say1111Hi, I'm 李明. Say2222Hi, I'm 郑智. Say1111Hi, I'm 郑智. Say2222Hi, I'm 李明. Say1111Hi, I'm 李明. Say2222

从而证明了匿名字段方法集的3条规则。

接口转换类似于说是接口继承规则 可认为是实现复杂接口（方法多）向简单接口（方法少）转换，其中简单接口中的方法在复杂接口中均有声明 。例如：

package main

import(

    "fmt")

type People struct {

    Name string}

type Student struct{

    People

    School string}

func (p People) GetPeopleInfo() {

    fmt.Println(p)

}

func (s Student) GetStudentInfo() {

    fmt.Println(s)

}

type PeopleInfo interface{

    GetPeopleInfo()

}

type StudentInfo interface{

    GetPeopleInfo()

    GetStudentInfo()

}

func main() {

    varisStudentInfo = Student{People{"李明"},"Yele University"}

    is.GetStudentInfo()

    is.GetPeopleInfo()

    varip PeopleInfo =is    ip.GetPeopleInfo()

    ///ip.GetStudentInfo()  note:ip.GetStudentInfo undefined}

④接口类型推断：Comma-ok断言和Switch测试

 利用接口类型推断可以 反向知道接口类型变量里面实际保存的是哪一种类型的对象。

Go语言中，常用两种方法可以进行接口类型推断，即Comma-ok断言和Switch测试

Comma-ok断言使用格式如下

value,ok = element.(T)

用法示例：

//利用Comma-ok断言进行接口类型推断package main

import(

    "fmt")

type People struct{

    Name string    Age int}//定义空接口用于存储任意类型数据类型type Objectinterface{}

func main() {

    people := People{"张三",20}

    objs := make([]Object,4)

    objs[0], objs[1], objs[2], objs[3] =1,true,"Hello", people

    forindex, element := range objs{

        ifvalue, ok := element.(int); ok{

            fmt.Printf("objs[%d]类型是int,value=%d\n", index, value)

        }elseifvalue, ok := element.(bool); ok{

            fmt.Printf("objs[%d]类型是bool,value=%v\n", index, value)

        }elseifvalue, ok := element.(string); ok{

            fmt.Printf("objs[%d]类型是string,value=%s\n", index, value)

        }elseifvalue, ok := element.(People); ok{

            fmt.Printf("objs[%d]类型是Peole,value=%v\n", index, value)

        }else{

            fmt.Printf("objs[%d]类型未知\n", index)

        }

    }

}

结果是这样的：

objs[0]类型是int,value=1objs[1]类型是bool,value=trueobjs[2]类型是string,value=Hello

objs[3]类型是Peole,value={张三20}

使用Switch测试判断接口类型，程序结构更加简洁，示例如下（只修改了示例中的main函数）：

func main() {

    people := People{"张三",20}

    objs := make([]Object,4)

    objs[0], objs[1], objs[2], objs[3] =1,true,"Hello", people

    forindex, element := range objs{

        switchvalue := element.(type){

        caseint:

            fmt.Printf("objs[%d]类型是int,value=%d\n", index, value)

        casebool:

            fmt.Printf("objs[%d]类型是bool,value=%v\n", index, value)

        casestring:

            fmt.Printf("objs[%d]类型是string,value=%s\n", index, value)

        case People:

            fmt.Printf("objs[%d]类型是Peole,value=%v\n", index, value)

        default:

            fmt.Printf("objs[%d]类型未知\n", index)

        }

    }

}