【Go语言】面向对象扩展——接口

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)

        }

    }

}

推荐阅读更多精彩内容