脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go语言接口的用法详解

Go语言接口的用法详解

2022-07-13 19:56奋斗的大橙子 Golang

本文详细讲解了Go语言接口的用法，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

一、接口的定义和好处

我们都知道接口给类提供了一种多态的机制，什么是多态，多态就是系统根据类型的具体实现完成不同的行为。

以下代码简单说明了接口的作用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main
 
import (
    "fmt"
    "io"
    "net/http"
    "os"
)
 
// init 在main 函数之前调用
func init() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ./example2 <url>")
        os.Exit(-1)
    }
}
 
// main 是应用程序的入口
func main() {
    // 从Web 服务器得到响应
    r, err := http.Get(os.Args[1])
    if err != nil {
        fmt.Println(err)
        return
    }
 
    // 从Body 复制到Stdout
    io.Copy(os.Stdout, r.Body)
    if err := r.Body.Close(); err != nil {
        fmt.Println(err)
    }
}

①注意下 http.Get(os.Args[1]) 这里他的返回值r是一个Response对象的指针，也就是请求的结果

做过web开发的都知道，下面是源代码

?
1
2
3
func Get(url string) (resp *Response, err error) {
    return DefaultClient.Get(url)
}

以下是Response的结构，这里有一个Body，是一个io.ReadCloser类型的，这是啥？往下看

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type Response struct {
    Status string // e.g. "200 OK"
    StatusCode int // e.g. 200
    Proto string // e.g. "HTTP/1.0"
    ProtoMajor int // e.g. 1
    ProtoMinor int // e.g. 0
    Header Header
    Body io.ReadCloser
    ContentLength int64
    TransferEncoding []string
    Close bool
    Uncompressed bool
    Trailer Header
    Request *Request
    TLS *tls.ConnectionState
}

ReadCloser是一个接口哦！Reader和Closer也同样是接口，接口里面都是方法。

?
1
2
3
4
type ReadCloser interface {
    Reader
    Closer
}

Reader接口

?
1
2
3
type Reader interface {
    Read(p []byte) (n int, err error)
}

Closer接口

?
1
2
3
type Closer interface {
    Close() error
}

②io.Copy(os.Stdout, r.Body) 这个方法,查看源码如下

?
1
2
3
func Copy(dst Writer, src Reader) (written int64, err error) {
    return copyBuffer(dst, src, nil)
}

这里的输入参数dst是一个实现了Writer接口的对象，而src则是一个实现了Reader接口的对象，由此，我们可以知道为什么io.Copy(os.Stdout, r.Body)的第二个参数可以传r.Body了，因为①中展示了Body这个对象是实现了Reader接口的。同理os.Stdout对象这个接口值表示标准输出设备，并且已经实现了io.Writer 接口

os.Stdout返回的是一个*File, File里面只有一个*file，而*file是实现了下面两个接口的，下面是Go的源码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
func (f *File) Read(b []byte) (n int, err error) {
    if err := f.checkValid("read"); err != nil {
        return 0, err
    }
    n, e := f.read(b)
    return n, f.wrapErr("read", e)
}
 
func (f *File) Write(b []byte) (n int, err error) {
    if err := f.checkValid("write"); err != nil {
        return 0, err
    }
    n, e := f.write(b)
    if n < 0 {
        n = 0
    }
    if n != len(b) {
        err = io.ErrShortWrite
    }
 
    epipecheck(f, e)
 
    if e != nil {
        err = f.wrapErr("write", e)
    }
 
    return n, err
}

所以说*File本身是继承了Writer和Reader接口的类型。

综上有了参数或者返回值是接口类型，就不用关注于具体的返回类型是什么，只要实现了的接口的方法都是可以被接受的。

二、接口值和实际对象值是怎么转化和存储的

我们都知道 如果一个类型实现了某个接口，那么这个类型的实际值是可以赋值给一个接口的变量的。

在C#中是这样的,例如将一个List赋值给一个IEnumerable类型的变量

?
1
IEnumerable<int> list = new List<int>();　

在Go语言中也是这样的，请看下面的代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main
 
import (
    "fmt"
)
 
type eat interface{
    eat()(string)
}
 
type Bird struct
{
    Name string
}
 
func (bird Bird) eat()string{
    return "Bird:"+bird.Name+" eat"
}
 
func print(e eat){
    fmt.Println(e.eat())
}
 
// main 是应用程序的入口
func main() {
 
    bird1:= Bird{Name:"Big"}
    bird2:= new(Bird)
    bird2.Name = "Small"
 
    print(bird1)
    print(bird2)
 
    var eat1 eat
    eat1 = bird1
    print(eat1)
}

结果

Bird:Big eat

Bird:Small eat

Bird:Big eat

这里定义了一个eat接口，有一个Bird的类型实现了该接口，print函数接受一个eat接口类型的参数，

这里可以看到前两次直接把bird1和bird2作为参数传入到print函数内，第二次则是声明了一个eat接口类型的变量eat1，然后将bird1进行了赋值。换句话说接口类型变量实际承载了实际类型值。这里是如何承载的呢？

这里我们把 eat1 称作 接口值，将bird1称作实体类型值，eat1和bird1的关系如下：

Go语言接口的用法详解

接口值可以看成两部分组合（都是指针）而成的。第一部分是【iTable的地址】第二部分是【实体类型值的地址】

关于interface的解析：

http://www.tuohang.net/article/234548.html

三、方法集的概念

简单的讲：方法集定义了接口的接受规则

举例说明：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main
 
import (
    "fmt"
)
 
type notifier interface {
    notify()
}
 
type user struct {
    name string
    email string
}
 
func (u user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n",
        u.name,
        u.email)
}
 
func sendNotification(n notifier) {
    n.notify()
}
 
func main() {
    u := user{"Bill", "bill@email.com"}
    sendNotification(u)
 
}

如上代码，定义了一个notifier接口，有一个方法nitify()方法，定义了一个user类型的结构，实现了notify方法，接收者类型是user，即实现了notifier接口，又定义了一个sendNotification方法，接收一个实现notifier接口的类型，并调用notify方法。

?
1
2
3
4
5
6
7
8
9
10
func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n",
        u.name,
        u.email)
}
 
func main() {
    u := user{"Bill", "bill@email.com"}
    sendNotification(u)
}

现在修正一下代码，将接收者改为user的指针类型。此时会发现原来调用的地方会出现错误。

?
1
cannot use u (type user) as type notifier in argument to sendNotification:user does not implement notifier (notify method has pointer receiver)

不能将u（类型是user）作为sendNotification 的参数类型notifier：user 类型并没有实现notifier（notify 方法使用指针接收者声明）

为什么会出现上面的问题？要了解用指针接收者来实现接口时为什么user 类型的值无法实现该接口，需要先了解方法集。方法集定义了一组关联到给定类型的值或者指针的方法。

定义方法时使用的接收者的类型决定了这个方法是关联到值，还是关联到指针，还是两个都关联。

以下是Go语言规范中的方法集：

Go语言接口的用法详解

上表的意思是：类型的值只能实现值接收者的接口；指向类型的指针，既可以实现值接收者的接口，也可以实现指针接收者的接口。

从接收者的角度来看一下这些规则

Go语言接口的用法详解

如果是值接收者，实体类型的值和指针都可以实现对应的接口；如果是指针接收者，那么只有类型的指针能够实现对应的接口。

所以针对上面的问题，将传入的u变成传入地址就可以了（可以套用一下表格，接收者*user对应的values是*user，所以传地址对应上面表格浅蓝色部分）

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func (u *user) notify() {
 
    fmt.Printf("Sending user email to %s<%s>\n",
 
        u.name,
 
        u.email)
 
}
 
func main() {
 
    u := user{"Bill", "bill@email.com"}
 
    sendNotification(&u)
 
}

综上我们总结一下，也就是说如果你的方法的接受者的类型是指针类型，那么方法的实现者就只能是指向该类型的指针类型，如果方法的接收者是值类型，那么方法的实现者可以是值类型也可以是指向该类型的指针类型。

面试题一个，下面的代码能否编译通过？

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
import (
    "fmt"
)
type People interface {
    Speak(string) string
}
type Stduent struct{}
func (stu *Stduent) Speak(think string) (talk string) {
    if think == "bitch" {
        talk = "You are a good boy"
    } else {
        talk = "hi"
    }
    return
}
func main() {
    var peo People = Stduent{}
    think := "bitch"
    fmt.Println(peo.Speak(think))
}

答案：不能。

分析：首先Speak的方法的接收者是*Student , 根据上面的规则，那么实现该方法的实现者只能是 *Student，但是 var peo People = Student{} 这里却将Student作为实现者赋值给了接口，这里就会出现问题。Integer(25)是一个字面量，而字面量是一个常量，所以没有办法寻址。

四、多态

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// Sample program to show how polymorphic behavior with interfaces.
package main
 
import (
    "fmt"
)
 
type notifier interface {
    notify()
}
 
// user defines a user in the program.
type user struct {
    name string
    email string
}
 
func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n",
        u.name,
        u.email)
}
 
type admin struct {
    name string
    email string
}
 
func (a *admin) notify() {
    fmt.Printf("Sending admin email to %s<%s>\n",
        a.name,
        a.email)
}
 
// main is the entry point for the application.
func main() {
    // Create a user value and pass it to sendNotification.
    bill := user{"Bill", "bill@email.com"}
    sendNotification(&bill)
 
    // Create an admin value and pass it to sendNotification.
    lisa := admin{"Lisa", "lisa@email.com"}
    sendNotification(&lisa)
}
 
func sendNotification(n notifier) {
    n.notify()
}

上面的代码很好的说明的接口的多态，user和admin都实现了notify方法，既实现了的notifier接口，sendNotification函数接收一个实现notifier接口的实例，从而user和admin都可以当作参数使用sendNotification函数，而sendNotification里面的notify方法执行根据的是具体传入的实例中实现的方法。

到此这篇关于Go语言接口的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://www.cnblogs.com/dcz2015/p/10103353.html

  • 接口
  • GO语言

    • 延伸 · 阅读

    精彩推荐
    • GolangGo语言获取数组长度的方法

      Go语言获取数组长度的方法

      这篇文章主要介绍了Go语言获取数组长度的方法,实例分析了len函数的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下 ...

      pythoner43682020-04-19
    • Golanggo语言实现抓取高清图片

      go语言实现抓取高清图片

      本文给大家分享的是使用go语言实现的抓取高清美女图片的代码，原理非常简单，这里就不多废话了，主要是看到很多小伙伴使用python实现的，心血来潮就...

      脚本之家4722020-04-24
    • Golanggolang 实现两个结构体复制字段

      golang 实现两个结构体复制字段

      这篇文章主要介绍了golang 实现两个结构体复制字段，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      butterfly52113148852021-06-06
    • GolangGolang并发操作中常见的读写锁详析

      Golang并发操作中常见的读写锁详析

      Golang中的锁机制主要包含互斥锁和读写锁互斥锁互斥锁是传统并发程序对共享资源进行控制访问的主要手段,这篇文章主要给大家介绍了关于Golang并发操作中...

      ReganYue11432021-09-17
    • GolangGo语言string，int，int64 ,float之间类型转换方法

      Go语言string，int，int64 ,float之间类型转换方法

      Go语言中int类型和string类型都是属于基本数据类型,两种类型的转化都非常简单。下面通过本文给大家分享Go语言string，int，int64 ,float之间类型转换方法，感...

      哪来的查克拉42132020-05-07
    • GolangGolang爬虫框架 colly的使用

      Golang爬虫框架 colly的使用

      本文主要介绍了Golang爬虫框架 colly的使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小...

      小馨whisper6812022-07-11
    • GolangGo工程化(一) 架构整洁之道阅读笔记

      Go工程化(一) 架构整洁之道阅读笔记

      本系列为极客时间 Go 进阶训练营笔记，全文接近 2W 字，篇幅较长，采用书中重点摘录+不成熟的个人小结组成，桌面端可以点击右侧目录快速定位到你感兴...

      mohuishou6552021-03-21
    • Golanggo Cobra命令行工具入门教程

      go Cobra命令行工具入门教程

      Cobra是一个用Go语言实现的命令行工具并且现在正在被很多项目使用，例如：Kubernetes、Hugo和Github CLI等，通过使用Cobra，我们可以快速的创建命令行工具，特...

      Go和分布式IM11912022-06-24
    最近更新
    编辑推荐
    阅读排行
    热门标签
    recovering 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图