Go基础系列:Go接口

博客园首页 William 91浏览 0评论

接口用法简介

接口(interface)是一种类型,用来定义行为(方法)。

type Namer interface {
    my_method1()
    my_method2(para)
    my_method3(para) return_type
    ...
}

但这些行为不会在接口上直接实现,而是需要用户自定义的方法来实现。所以,在上面的Namer接口类型中的方法my_methodN都是没有实际方法体的,仅仅只是在接口Namer中存放这些方法的签名(签名 = 函数名+参数(类型)+返回值(类型))。

当用户自定义的类型实现了接口上定义的这些方法,那么自定义类型的值(也就是实例)可以赋值给接口类型的值(也就是接口实例)。这个赋值过程使得接口实例中保存了用户自定义类型实例。

例如:

package main

import (
    "fmt"
)

// Shaper 接口类型
type Shaper interface {
    Area() float64
}

// Circle struct类型
type Circle struct {
    radius float64
}

// Circle类型实现Shaper中的方法Area()
func (c *Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

// Square struct类型
type Square struct {
    length float64
}

// Square类型实现Shaper中的方法Area()
func (s *Square) Area() float64 {
    return s.length * s.length
}

func main() {
    // Circle类型的指针类型实例
    c := new(Circle)
    c.radius = 2.5

    // Square类型的值类型实例
    s := Square{3.2}

    // Sharpe接口实例ins1,它只能是值类型的
    var ins1 Shaper
    // 将Circle实例c赋值给接口实例ins1
    // 那么ins1中就保存了实例c
    ins1 = c
    fmt.Println(ins1)

    // 使用类型推断将Square实例s赋值给接口实例
    ins2 := s
    fmt.Println(ins2)
}

上面将输出:

&{2.5}
{3.2}

从上面输出结果中可以看出,两个接口实例ins1和ins2被分别赋值后,分别保存了指针类型的Circle实例c和值类型的Square实例s

另外,从上面赋值ins1和ins2的赋值语句上看:

ins1 = c
ins2 := s

是否说明接口实例ins就是自定义类型的实例?实际上接口是指针类型(指向什么见下文)。这个时候,自定义类型的实例c、s称为具体实例,ins实例是抽象实例,因为ins接口中定义的行为(方法)并没有具体的行为模式,而c、s中的行为是具体的。

因为接口实例ins也是自定义类型的实例,所以当接口实例中保存了自定义类型的实例后,就可以直接从接口上调用它所保存的实例的方法。例如:

fmt.Println(ins1.Area())   // 输出19.625
fmt.Println(ins2.Area())   // 输出10.24

这里ins1.Area()调用的是Circle类型上的方法Area(),ins2.Area()调用的则是Square类型上的方法Area()。这说明Go的接口可以实现面向对象中的多态:可以按需调用名称相同、功能不同的方法

接口实例中存的是什么

前面说了,接口类型是指针类型,但是它到底存放了什么东西?

接口类型的数据结构是2个指针,占用2个机器字长。

当将类型实例c赋值给接口实例ins1后,用println()函数输出ins1和c,比较它们的地址:

println(ins1)
println(c)

输出结果:

(0x4ceb00,0xc042068058)
0xc042068058

从结果中可以看出,接口实例中包含了两个地址,其中第二个地址和类型实例c的地址是完全相同的。而第二个地址c是Circle的指针类型实例,所以ins中的第二个值也是指针。

ins中的第一个是指针是什么?它所指向的是一个内部表结构iTable,这个Table中包含两部分:第一部分是实例c的类型信息,也就是*Circle,第二部分是这个类型(Circle)的方法集,也就是Circle类型的所有方法(此示例中Circle只定义了一个方法Area())。

所以,如图所示:

注意,上图中的实例c是指针,是指针类型的Circle实例。

对于值类型的Square实例s,ins2保存的内容则如下图:

方法集(Method Set)规则

官方手册对Method Set的解释:https://golang.org/ref/spec#Method_sets

实例的method set决定了它所实现的接口,以及通过receiver可以调用的方法。

方法集是类型的方法集合,对于非接口类型,每个类型都分两个Method Set:值类型实例是一个Method Set,指针类型的实例是另一个Method Set。两个Method Set由不同receiver类型的方法组成:

实例的类型       receiver
--------------------------------------
 值类型:T       (T Type)
 指针类型:*T    (T Type)或(T *Type)

也就是说:

  • 值类型的实例的Method Set只由值类型的receiver(T Type)组成
  • 指针类型的实例的Method Set由值类型和指针类型的receiver共同组成,即(T Type)(T *Type)

这是什么意思呢?从receiver的角度去考虑:

receiver        实例的类型
---------------------------
(T Type)        T 或 *T
(T *Type)       *T

上面的意思是:

  • 如果某类型实现接口的方法的receiver是(T *Type)类型的,那么只有指针类型的实例*T才算是实现了这个接口
  • 如果某类型实现接口的方法的receiver是(T Type)类型的,那么值类型的实例T和指针类型的实例*T都算实现了这个接口

举个例子。接口方法Area(),自定义类型Circle有一个receiver类型为(c *Circle)的Area()方法时,说明实现了接口的方法,但只有Circle实例的类型为指针类型时,这个实例才算是实现了接口,才能赋值给接口实例,才能当作一个接口参数。如下:

package main

import "fmt"

// Shaper 接口类型
type Shaper interface {
    Area() float64
}

// Circle struct类型
type Circle struct {
    radius float64
}

// Circle类型实现Shaper中的方法Area()
// receiver类型为指针类型
func (c *Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

func main() {
    // 声明2个接口实例
    var ins1, ins2 Shaper

    // Circle的指针类型实例
    c1 := new(Circle)
    c1.radius = 2.5
    ins1 = c1
    fmt.Println(ins1.Area())

    // Circle的值类型实例
    c2 := Circle{3.0}
    // 下面的将报错
    ins2 = c2
    fmt.Println(ins2.Area())
}

报错结果:

cannot use c2 (type Circle) as type Shaper
in assignment:
        Circle does not implement Shaper (Area method has
pointer receiver)

它的意思是,Circle值类型的实例c2没有实现Share接口的Area()方法,它的Area()方法是指针类型的receiver。换句话说,值类型的c2实例的Method Set中没有receiver类型为指针的Area()方法

所以,上面应该改成:

ins2 = &c2

再声明一个方法,它的receiver是值类型的。下面的代码一切正常。

type Square struct{
    length float64
}

// 实现方法Area(),receiver为值类型
func (s Square) Area() float64{
    return s.length * s.length
}

func main() {
    var ins3,ins4 Shaper

    // 值类型的Square实例s1
    s1 := Square{3.0}
    ins3 = s1
    fmt.Println(ins3.Area())

    // 指针类型的Square实例s2
    s2 := new(Square)
    s2.length=4.0
    ins4 = s2
    fmt.Println(ins4.Area())
}

很经常的,我们会直接使用推断类型的赋值方式(如ins2 := c2)将实例赋值给一个变量,我们以为这个变量是接口的实例,但实际上并不一定。正如上面值类型的c2赋值给ins2,这个ins2将是从c2数据结构拷贝而来的另一个副本数据结构,并非接口实例,但这时通过ins2也能调用Area()方法:

c2 = Circle{3.2}
ins2 := c2
fmt.Println(ins2.Area())  // 正常执行

之所以能调用,是因为Circle类型中有Area()方法,但这不是通过接口去调用的。

所以,在使用接口的时候,应当尽量使用var先声明接口类型的实例,再将类型的实例赋值给接口实例(如var ins1,ins2 Shaper),或者使用ins1 := Shaper(c1)的方式。这样,如果赋值给接口实例的类型实例没有实现该接口,将会报错。

但是,为什么要限制指针类型的receiver只能是指针类型的实例的Method Set呢?

看下图,假如指针类型的receiver可以组成值类型实例的Method Set,那么接口实例的第二个指针就必须找到值类型的实例的地址。但实际上,并非所有值类型的实例都能获取到它们的地址。

哪些值类型的实例找不到地址?最常见的是那些简单数据类型的别名类型,如果匿名生成它们的实例,它们的地址就会被Go彻底隐藏,外界找不到这个实例的地址。

例如:

package main

import "fmt"

type myint int

func (m *myint) add() myint {
    return *m + 1
}
func main() {
    fmt.Println(myint(3).add())
}

以下是报错信息:找不到myint(3)的地址

abc\abc.go:11:22: cannot call pointer method on myint(3)
abc\abc.go:11:22: cannot take the address of myint(3)

这里的myint(3)是匿名的myint实例,它的底层是简单数据类型int,myint(3)的地址会被彻底隐藏,只会提供它的值对象3。

接口类型作为参数

将接口类型作为参数很常见。这时,那些实现接口的实例都能作为接口类型参数传递给函数/方法。

例如,下面的myArea()函数的参数是n Shaper,是接口类型。

package main

import (
    "fmt"
)

// Shaper 接口类型
type Shaper interface {
    Area() float64
}

// Circle struct类型
type Circle struct {
    radius float64
}

// Circle类型实现Shaper中的方法Area()
func (c *Circle) Area() float64 {
    return 3.14 * c.radius * c.radius
}

func main() {
    // Circle的指针类型实例
    c1 := new(Circle)
    c1.radius = 2.5
    myArea(c1)
}

func myArea(n Shaper) {
    fmt.Println(n.Area())
}

上面myArea(c1)是将c1作为接口类型参数传递给n,然后调用c1.Area(),因为实现了接口方法,所以调用的是Circle的Area()。

如果实现接口方法的receiver是指针类型的,但却是值类型的实例,将没法作为接口参数传递给函数,原因前面已经解释过了,这种类型的实例没有实现接口。

以接口作为方法或函数的参数,将使得一切都变得灵活且通用,只要是实现了接口的类型实例,都可以去调用它。

用的非常多的fmt.Println(),它的参数也是接口,而且是变长的接口参数:

$ go doc fmt Println
func Println(a ...interface{}) (n int, err error)

每一个参数都会放进一个名为a的Slice中,Slice中的元素是接口类型,而且是空接口,这使得无需实现任何方法,任何东西都可以丢带fmt.Println()中来,至于每个东西怎么输出,那就要看具体情况。

接口类型的嵌套

接口可以嵌套,嵌套的内部接口将属于外部接口,内部接口的方法也将属于外部接口。

例如,File接口内部嵌套了ReadWrite接口和Lock接口。

type ReadWrite interface {
    Read(b Buffer) bool
    Write(b Buffer) bool
}
type Lock interface {
    Lock()
    Unlock()
}
type File interface {
    ReadWrite
    Lock
    Close()
}

除此之外,类型嵌套时,如果内部类型实现了接口,那么外部类型也会自动实现接口,因为内部属性是属于外部属性的。


注:www2014.aspxhtml.com转载自cnblogs,若看不到图片,请移步来源网址查看。
via:https://www.cnblogs.com/f-ck-need-u/p/9898038.html

转载请注明:AspxHtml学习分享网 » Go基础系列:Go接口

发表我的评论
取消评论

表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址