接口定义了一个对象的行为规范,接口只定义规范不实现,由具体的对象来实现规范的细节。
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
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语言中使用十分广泛。
关于接口需要注意的是,只有当有两个或两个以上的具体类型必须调用相同的方法时,我们才需要定义接口。
不要为了接口而写接口,只在需要的时候书写,避免不必要的内存空间浪费。
来源:51CTO
作者:DevOperater
链接:https://blog.51cto.com/10983441/2469439