11.Go语言基础之接口

…衆ロ難τιáo~ 提交于 2020-02-06 16:46:31
接口定义了一个对象的行为规范,接口只定义规范不实现,由具体的对象来实现规范的细节。

1.1接口类型

在Go语言中,接口(interface)是一种类型,一种抽象的类型。
interface是一组method的集合,是duck-type programming的一种体现。
接口做的事情就像是定义一个协议(规则),只要一台机器有洗衣服和甩干的功能,就是洗衣机。不关心属性(数据),只关心行为(方法)。
在Java中,也是有接口的概念的。

1.2为什么要使用接口

package main

import "fmt"

type Cat struct {}

func (c Cat) say() string  {
    return "喵喵喵"
}
type Dog struct {}

func (d Dog) say() string {
    return "汪汪汪"
}
func main()  {
    var c Cat
    fmt.Println("猫:",c.say())

    var d Dog
    fmt.Println("狗:",d.say())
}

结果:
猫: 喵喵喵
狗: 汪汪汪

Process finished with exit code 0
上面的代码中定义了猫和狗,都会叫,你会发现main函数中有明显的代码重复,如果动物越多,那么say()函数会越多,那怎样优化呢?
可以使用接口!

1.3接口的定义

Go语言提倡面向接口编程。
每个接口由数个方法组成,接口的定义格式如下:

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

其中:
接口名:使用type将接口定义为自定义的类型名。
    Go语言的接口在命名时,一般会在单词后面添加er,如有写操作的接口叫Writer,有字符串功能的接口叫Stringer等。
    接口名最好要能突出该接口的类型含义。
方法名:当方法名首字母是大写且这个接口类型名首字母是大写时,这个方法可以被接口所在的包(package)之外的代码访问。
参数列表、返回值列表:参数列表和返回值列表中的参数变量名可以省略。

例如:
type writer interface{
    Write([]byte) error
}

当看到这个接口类型的值时i,不知道它是什么,唯一知道的就是通过它的Writer方法来做一些事情。

1.4实现接口的条件

一个对象只要全部实现了接口中的方法,那么就实现了这个接口。即接口就是一个需要实现的方法列表。
package main

import "fmt"

//定义一个Sayer接口
type Sayer interface {
    say()
}

//定义dog和cat两个结构体
type dog struct {}
type cat struct {}
//因为Sayer接口中只有一个say方法,所以我们只需要给dog和cat分别实现say()方法,就能实现Sayer接口了。
func (d dog) say()  {
    fmt.Println("汪汪汪")
}
func (c cat) say()  {
    fmt.Println("喵喵喵")
}
//接口实现就是这样,只要实现了接口中的所有方法,就实现了这个接口。
func main()  {
    var d dog
    var c cat
    d.say()
    c.say()
}

结果:
汪汪汪
喵喵喵

Process finished with exit code 0

1.5接口类型变量

那么实现了接口有什么用呢?
接口类型变量能够存储所有实现了该接口的实例。
例如上面的示例中,Sayer类型的变量能够存储dog和cat类型的变量。
package main

import "fmt"

//定义一个Sayer接口
type Sayer interface {
    say()
}

//定义dog和cat两个结构体
type dog struct {}
type cat struct {}
//因为Sayer接口中只有一个say方法,所以我们只需要给dog和cat分别实现say()方法,就能实现Sayer接口了。
func (d dog) say()  {
    fmt.Println("汪汪汪")
}
func (c cat) say()  {
    fmt.Println("喵喵喵")
}
//接口实现就是这样,只要实现了接口中的所有方法,就实现了这个接口。
func main()  {
    var x Sayer //声明一个Sayer类型的变量x
    c := cat{}  //实例化一个cat
    d := dog{}  //实例化一个dog
    x = c       //可以吧cat示例直接赋值给x
    x.say()     //喵喵喵
    x = d       //可以吧dog实力直接赋值给x
    x.say()     //汪汪汪
}

结果:
喵喵喵
汪汪汪

Process finished with exit code 0

1.6值接收者和指针接收者实现接口的区别

使用值接收者实现接口和使用指针接收者实现接口有什么区别呢?看一下下面的例子

值接收者实现接口

package main

import "fmt"

type Mover interface {
    move()
}
type dog struct {}
//值接收者实现接口
func (d dog) move()  {
    fmt.Println("狗会动!")
}
func main()  {
    var x Mover
    var wangcai = dog{} //旺财是dog类型
    x = wangcai         //x可以接收dog类型
    x.move()

    var fugui = &dog{}  //富贵是*dog类型
    x = fugui           //x可以接收*dog类型
    x.move()
}

结果:
狗会动!
狗会动!

Process finished with exit code 0
从上面的代码中我们可以发现,使用值接收者实现接口侯,不管是dog结构体还是结构体指针*dog类型的变量,都可以赋值给改接口变量。
因为Go语言中有对指针类型变量求值的语法糖,dog指针fugui内部会自动求值。

指针接收者实现接口

package main

import "fmt"

type Mover interface {
    move()
}
type dog struct {}
//值接收者实现接口
func (d *dog) move()  {
    fmt.Println("狗会动!")
}
func main()  {
    var x Mover
    var wangcai = dog{} //旺财是dog类型
    x = wangcai         //x不可以接收dog类型,直接报错
    x.move()

    var fugui = &dog{}  //富贵是*dog类型
    x = fugui           //x可以接收*dog类型
    x.move()
}
此时实现Mover接口的是*dog类型,所以不能给x传入dog类型的wangcai,此时x只能存储*dog类型的值。

面试题

首先请观察下面的这段代码,然后请回答这段代码能不能通过编译?

type People interface {
    Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
    if think == "sb" {
        talk = "你是个大帅哥"
    } else {
        talk = "您好"
    }
    return
}

func main() { 
    var peo People = Student{}  //不能通过编译,这里要变为var peo People = &Student{}
    think := "思考"
    fmt.Println(peo.Speak(think))
}

1.7类型与接口的关系

1.7.1一个类型实现多个接口

一个类型可以同时实现多个接口,而接口间,彼此是独立的,不知道对方的实现。
例如,狗可以叫,也可以动。我们可以分别定义Sayer接口和Mover接口。
package main

import "fmt"

type Mover interface {
    move()
}
type Sayer interface {
    say()
}
type dog struct {
    name string
}
//实现Mover接口
func (d dog) move()  {
    fmt.Printf("%s狗会动!\n",d.name)
}
//实现Sayer接口
func (d dog) say()  {
    fmt.Printf("%s狗会叫!\n",d.name)
}
func main()  {
    var x Sayer
    var y Mover

    //dog既可以实现Sayer接口,也可以实现Mover接口
    var a = dog{name:"旺财"}
    x = a
    y = a
    x.say()
    y.move()
}

结果:
旺财狗会叫!
旺财狗会动!

Process finished with exit code 0

1.7.2多个类型实现同一个接口

package main

import "fmt"
//Go语言中不同的类型可以实现同一个接口,首先定义一个Mover接口
type Mover interface {
    move()
}

type dog struct {
    name string
}
type car struct {
    brand string
}
//dog实现Mover接口
func (d dog) move()  {
    fmt.Printf("%s狗会动!\n",d.name)
}
//car实现Mover接口
func (c car) move()  {
    fmt.Printf("%s小车会跑!\n",c.brand)
}
//这时候就可以在代码中把狗和汽车当成一个会动的物体来处理,不需要关注它们具体是什么,只需要调用它们的move方法就可以了。
func main()  {
    var x Mover

    //dog既可以实现Sayer接口,也可以实现Mover接口
    var a = dog{name:"旺财"}
    var b = car{brand:"宝马"}
    x = a
    x.move()
    x = b
    x.move()
}

结果:
旺财狗会动!
宝马小车会跑!

Process finished with exit code 0
一个接口的方法,不一定需要由一个类型完全实现,接口的方法可以通过在类型中嵌入其他类型或结构体来实现。

package main

import "fmt"

//洗衣机接口
type WashingMachine interface {
    wash()
    dry()
}
//甩干器
type dryer struct {}
//海尔洗衣机
type haier struct {
    dryer //嵌入甩干器
}

//实现WashingMachine接口的dry()方法
func (d dryer) dry()  {
    fmt.Println("甩一甩")
}
//实现WashingMachine接口的wash()方法
func (h haier) wash()  {
    fmt.Println("wash")
}
func main()  {
    var d dryer
    var h haier
    d.dry()
    h.wash()
    h.dry()

}

结果:
甩一甩
wash
甩一甩

Process finished with exit code 0

1.8接口嵌套

接口与接口之间可以通过嵌套创造出新的接口。
package main

import "fmt"

//Sayer接口
type Sayer interface {
    say()
}
//Mover接口
type Mover interface {
    move()
}

//接口嵌套
type animal interface {
    Sayer
    Mover
}
//嵌套得到的接口的使用与普通接口一样,这里让cat实现animal接口:
type cat struct {
    name string
}

func (c cat) say()  {
    fmt.Println("喵喵喵")
}
func (c cat) move()  {
    fmt.Println("猫会动")
}
func main()  {
    var x animal
    x = cat{name:"花花"}
    x.say()
    x.move()
}

结果:
喵喵喵
猫会动

Process finished with exit code 0

1.9空接口

1.9.1空接口的定义

空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。
空接口类型的变量可以存储任意类型的变量。
package main

import "fmt"

func main()  {
    var x interface{}
    s := "hello vita"
    x = s
    fmt.Printf("type:%T value:%v\n",x,x)
    i := 100
    x = i
    fmt.Printf("type:%T value:%v\n",x,x)
    b := true
    x = b
    fmt.Printf("type:%T value:%v\n",x,x)
}

结果:
type:string value:hello vita
type:int value:100
type:bool value:true

Process finished with exit code 0

1.9.2空接口的应用

空接口作为函数的参数

使用空接口实现可以接收任意类型的函数参数。

package main

import "fmt"

func show(x interface{})  {
    fmt.Printf("type:%T value:%v\n",x,x)
}
func main()  {
    show("hello vita")
    show(100)
    show(true)
}

结果:
type:string value:hello vita
type:int value:100
type:bool value:true

Process finished with exit code 0

空接口作为map的值

使用空接口,可以实现map的value是任意值。

package main

import "fmt"

func main()  {
    var studentInfo = make(map[string]interface{})
    studentInfo["name"] = "vita"
    studentInfo["age"] = 18
    studentInfo["married"] = true
    fmt.Println(studentInfo)
}

结果:
map[age:18 married:true name:vita]

Process finished with exit code 0

1.10类型断言

1.10.1接口值

空接口可以存储任意类型的值,那我们如何获取其存储的具体数据呢?

接口值:
一个接口的值(简称接口值)是由一个"具体类型"和"具体类型的值"两部分组成,这两部分分别称为接口的"动态类型"和"动态值"。

看下面的例子:
var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

11.Go语言基础之接口

1.10.2断言

想要判断空接口中的值,这时候可以使用类型断言,语法格式为:
x.(T)
其中:
x:表示类型为interface{}的变量
T:表示断言x可能是的类型
该语法返回两个参数,第一个参数是x转化为T类型后的变量,第二个值是一个布尔值,若为true则表示断言成功,为false表示断言失败。
package main

import "fmt"

func main()  {
    var x interface{}
    x = "hello vita"
    v,ok := x.(string)
    if ok{
        fmt.Println(v)
    }else{
        fmt.Println("类型不是string")
    }
}

结果:
hello vita

Process finished with exit code 0
上面的实例中,如果要断言多次就要写多个if判断,这个时候我们可以使用switch语句来实现:

package main

import "fmt"

func main()  {
    var x interface{}
    x= "hello"
    switch v := x.(type) {
    case string:
        fmt.Printf("x是string类型,value is %v\n",v)
    case int:
        fmt.Printf("x是int类型,value is %v\n",v)
    case bool:
        fmt.Printf("x是bool类型,value is %v\n",v)
    }
}

结果:
x是string类型,value is hello

Process finished with exit code 0
因为空接口可以存储任意类型的值,所以空接口咋子Go语言中使用十分广泛。
关于接口需要注意的是,只有当有两个或两个以上的具体类型必须调用相同的方法时,我们才需要定义接口。
不要为了接口而写接口,只在需要的时候书写,避免不必要的内存空间浪费。
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!