Go 接口

·  阅读 318
Go 接口

Hi,我是行舟,今天和大家一起学习Go语言的接口。

像Channel和协程一样,Go语言的接口设计也是其一大特色。不像Java、C++、PHP等语言,一个类要实现接口必须明确声明,在Go语言中一个类型只要实现了接口中所有的方法,就认为该类型实现了此接口。这种更加松散的实现方式,使面向对象编程变得更加简单。

声明接口

type 接口名称 interface{
    方法一(传入参数) (返回值)
    方法二(传入参数) (返回值)
}
复制代码

通过type 接口名称 interface来声明一个接口,在后面的大括号中定义实现接口需要的方法。Go语言的接口只有方法,没有属性。只要实现了所有方法的类型都可以认为实现了此接口,也被戏称Duck typing

Duck typing:如何判断一个动物是不是鸭子呢?如果一个动物走路、叫声、羽毛、形体和鸭子一样,我们就认为它是一只鸭子。引申一下就是通过判断一个对象的外表和动作决定它的类型。

基本用法

实现接口

例1:

// 声明Dog接口,包含getAge方法
type Dog interface{
   getAge()
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge()  {
   fmt.Printf("I am %d years old!",j.age)
}

func main()  {
   a1 := Jinmao{age:2}
   var d Dog= a1 // 声明Dog类型的实例d,并把a1赋值给d
   d.getAge()// print:I am 2 years old!
}
复制代码

如上示例,我们声明了Dog接口,Dog接口只包含getAge()方法。接着又定义了Jinmao结构体,Jinmao也实现了getAge方法,所以我们就可以说Jinmao实现了Dog接口。我们定义a1为Jinmao类型,接着定义d为Dog类型,因为a1所属类型实现了Dog接口,所以我们可以把a1赋值给d,d在调用getAge方法时,就会调用Jinmao实现的方法。

示例中有一个关键点需要留意:Jinmao结构体实现的getAge方法不仅仅名称和Dog的getAge方法一致,传入参数和返回值也必须完全一致,才认为Jinmao实现了Dog接口定义的getAge方法。

在Go语言中接口类型的零值是nil。

接口作用

在例1中我们虽然实现了接口,但是并没有体现出使用接口的价值。 例2:

// 声明Dog接口,包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

type Husky struct {
   age int
}

func (h Husky) getAge() int {
   return h.age
}

// 计算所有🐶🐶的年龄和
func AddAge(s []Dog) int {
   var sum int
   for _,v := range s{
      sum += v.getAge()
   }
   return sum
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1,并把a1赋值给d

   a2 := Husky{age: 3}
   var d2 Dog = a2 // 声明Dog类型的实例d2,并把a2赋值给d

   ageSum := AddAge([]Dog{d1,d2})
   fmt.Printf("狗狗年龄之和是:%d", ageSum)
}
复制代码

如上示例中,我们声明了Jinmao和Husky两个类型且都实现了Dog接口。方法AddAge接收元素为Dog类型的切片。我们声明a1是Jinmao类型并赋值给d1,a2是Husky类型并赋值给d2。接下来调用AddAge方法时候,在AddAge方法内部遍历各Dog类型的元素并调用getAge方法,元素会根据自己被赋予的实际类型执行各自的方法。

实际类型就是接口被赋予的实现此接口实际对象的类型。如例2中的var d1 Dog= a1,d1的类型就是a1(实际对象)所属的类型,a1属于Jinmao,所以Jinmao就是d1的实际类型

继续思考以上示例,我们增加Teddy类型,并实现Dog接口。当我们调用AddAge方法时,方法内部不用做任何修改。这就是接口给我们带来的好处。

接口类型

例3:

// 声明Dog接口,包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1,并把a1赋值给d
   fmt.Printf("d1的类型是:%T", d1) // d1的类型是:main.Jinmao
}
复制代码

在fmt包的Printf方法中,%T代表d1的类型。最终输出d1的实际类型是Jinmao。

空接口

我们用interface{}表示空接口。根据Go语言中接口的定义,实现了接口方法的对象都是接口的实现类型,空接口没有定义方法,那也 就意味着所有类型都实现了空接口

当方法可以接收任意类型的参数时,可以使用interface{}表示。

高级用法

接口类型

例4:

// 声明Dog接口,包含age方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1,并把a1赋值给d
   v,ok := d1.(Jinmao) // 判断d1的实际类型是否是Jinmao
   fmt.Printf("v=%v,ok=%v",v,ok) // print v={2},ok=true
}
复制代码

如上示例,我们通过v,ok := d1.(Jinmao)判断d1的实际类型。
一种更常见的方法是通过switch case语句判断数据的实际类型。
例5:

// 声明Dog接口,包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

type Husky struct {
   age int
}

func (h Husky) getAge() int {
   return h.age
}

func assertType(i interface{}){
   switch i.(type) {
   case Jinmao:
      fmt.Println("实际类型是Jinmao")
   case Husky:
      fmt.Println("实际类型是Husky")
   case int:
      fmt.Println("实际类型是int")
   default:
      fmt.Println("未匹配到类型")
   }
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1,并把a1赋值给d

   assertType(a1) // print 实际类型是Jinmao
   assertType(d1) // print 实际类型是Jinmao
   assertType(100// print 实际类型是int
   assertType("str"// print 未匹配到类型
}
复制代码

在例5中我们可以看到,如何通过switch i.(type){}语句判断变量的实际类型。

值类型和指针类型方法

在讲方法的时候我们说到有值类型和指针类型的方法,这两种类型的方法在实现接口时有何不同呢?
例6:

// 声明Dog接口,包含age方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

type Husky struct {
   age int
}

func (h *Husky) getAge() int {
   return h.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1,并把a1赋值给d1

   a2 := Jinmao{age:3}
   var d2 Dog= &a2 // 声明Dog类型的实例d1,并把a1赋值给d2

   //a3 := Husky{age:2}
   //var d3 Dog= a3 // 声明Dog类型的实例d1,并把a1赋值给d3

   a4 := Husky{age:4}
   var d4 Dog= &a4 // 声明Dog类型的实例d1,并把a1赋值给d4

   fmt.Println(d1.getAge()) // print 2
   fmt.Println(d2.getAge()) // print 3
   // fmt.Println(d3.getAge())
   fmt.Println(d4.getAge()) // print 4
}
复制代码

在上面的示例中,Jinmao的值类型实现了getAge(),a1是Jinmao的值类型,&a2是Jinmao的指针类型,a1和a2都可以赋值给Dog类型的值。Husky的指针类型实现了getAge(),a3是Husky的值类型,&a4是Husky的指针类型,此时只有&a4可以赋值Dog类型的d4。如果把a3赋值给d3会报编译时错误 Type does not implement 'Dog' as 'getAge' method has a pointer receiver。这是Go语言值类型方法和指针类型方法的特点,我们可以这样理解对象值类型的方法,也自动包含了指针类型的方法;而指针类型的方法不含值类型的方法

对象值类型的方法,也自动包含了指针类型的方法是因为Go语言在编译期做了优化。

接口嵌套

接口之间可以通过嵌套实现类似于继承的效果。
例7:

// 声明Dog接口,包含getAge方法
type Dog interface{
   getAge() int
}

// 声明Cat接口,包含getName方法
type Cat interface {
   getName() string
}
// Animal接口,嵌套了Dog和Cat接口
type Animal interface {
   Dog
   Cat
}

type Husky struct {
   age int
   name string
}

func (h Husky) getAge() int {
   println("I am Husky getAge!")
   return h.age
}

func (h Husky) getName() string {
   println("I am Husky getName!")
   return h.name
}

type OrangeCat struct {
   age int
   name string
}

func (o OrangeCat) getAge() int {
   println("I am OrangeCat getAge!")
   return o.age
}

func (o OrangeCat) getName() string {
   println("I am OrangeCat getName!")
   return o.name
}

func main()  {
   h1 := Husky{age:2,name:"xiaohei"}
   var a1 Animal= h1 // 声明Dog类型的实例d1,并把a1赋值给d1

   o1 := OrangeCat{age:1, name:"Tom"}
   var a2 Animal= o1 // 声明Dog类型的实例d1,并把a1赋值给d2

   fmt.Println(a1.getAge())
   fmt.Println(a1.getName())
   fmt.Println(a2.getAge())
   fmt.Println(a2.getName())
}
复制代码

执行例6的代码,输出如下结果:

I am Husky getAge!
2
I am Husky getName!
xiaohei
I am OrangeCat getAge!
0
I am OrangeCat getName!
Tom
复制代码

在例6中我们声明Animal接口包含了Dog和Cat接口,要想实现Animal接口就需要实现Dog和Cat接口的所有方法。我们给Husky和OrangeCat结构体类型都实现了getAge和getName方法,所以a1和a2可以被h1和o1赋值。

接口赋值

接口赋值对于值类型和指针类型有所不同,请看下面的例子。
例8

// 声明Dog接口,包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j *Jinmao) setAge(i int) {
   j.age = i
}

func (j Jinmao) getAge() int {
   return j.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1,并把a1赋值给d1
   a1.setAge(20)
   fmt.Printf("a1.age=%d \n",a1.getAge())
   fmt.Printf("d1.age=%d \n",d1.getAge())

   a2 := Jinmao{age:3}
   var d2 Dog= &a2 // 声明Dog类型的实例d2,并把a2赋值给d2
   a2.setAge(30)
   fmt.Printf("a1.age=%d \n",a2.getAge())
   fmt.Printf("a1.age=%d \n",d2.getAge())
}
复制代码

执行上面例8中的代码输出如下:

a1.age=20 
d1.age=2 
a1.age=30 
a1.age=30 
复制代码

通过结果我们可以看出,对a1调用setAge方法并没有改变d1的age;对a2调用setAge方法改变了d2的age。在Go语言中的赋值操作都是值拷贝, 但是d2拷贝的是a2的地址,所以d2和a2还是指向同一个内存地址,当a2的age改变时d2的age也改变了。

总结

本文我们主要介绍了Go语言接口的基本用法、嵌套使用、赋值原理等。接口在Go语言中极具特色,而且在面向对象编程中使用广泛。如果大家对文章内容有任何疑问或建议,欢迎私信交流。

我把Go语言基础知识相关文章的Demo都放到了下面这个仓库中,方便大家互相交流学习。 github.com/jialj/golan…

诚邀关注公众号:一行舟
每周更新技术文章,和大家一起进步。

分类:
后端
标签:
分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改