接口interface

golang是面向接口的编程语言，这是golang的语言特点之一。golang传统意义上的继承，多态等，它只支持封装。golang中的接口并不是传统（c/c++，java等）意义上的接口，而是传统面向对象中继承和多态在golang中是通过接口来完成的。在golang的interface出现之前，接口主要作为不同组建之间的契约存在的，对契约的实现是强制的，必须明确声明实现了这个接口。但是golang完全不同。多态是指代码可以根据类型的具体实现采用不同行为的能力，接口是一个或多个方法签名的集合，只要某个类型拥有该接口的所有方法签名，即算实现该接口，无需显示声明实现了哪个接口，这称为StructuralTyping，接口只有方法声明，没有实现，没有数据字段接口可以匿名嵌入其它接口，或嵌入到结构中，将对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针，只有当接口存储的类型和对象都为nil时，接口才等于nil，接口调用不会做receiver的自动转换，接口同样支持匿名字段方法，接口也可实现类似OOP中的多态，空接口可以作为任何类型数据的容器

eg:

type Traversal interface{
    Traverse()
}
func main(){
    traversal := getTraversal()
    traversal.Traverse()
}

通过getTraversal()方法封装得到了一个traversal，这个traversal实现了Traversal这个interface

duck typing

许多语言支持duck typing，包括c++，python，java无法实现duck typing。

duck typing的概念:像鸭子走路，像鸭子叫，长的像鸭子，那么它就是一只鸭子

duck typing的用途：描述事物的外部行为而非内部结构

在golang编程中就利用duck typing的方式进行，gopher不用在意调用方法的“类型”是一个什么，当gopher需要调用到某个方法时能提供这个方法即可，然后和这些方法进行互动

长得像鸭子就是鸭子，也就是说实现了interface就是实现了interface中定义的那个方法，那么实现该方法的struct就不用赋值给interface就拥有了这个能力。也就是说实现了这个struct的实例可以被fmt.Println调用。但是在定义的时候其实是interface实例被调用。只不过这个struct实现了这个接口，所以它也拥有了这个能力。

严格说来go属于结构化类型系统，类似duck typing，因为在定义duck typing时强调了“动态绑定”，但是golang是编译时就绑定了，从这个角度看,golang就不是duck typing

golang接口的定义

graph LR
使用者-->实现者

golang中，一个类只需要实现接口要求的所有函数，我们就说这个类实现了这个接口

golang的非侵入式接口，看似做了很小的语法调整，实则影响很是深远：

1. go标准库，再也不需要绘制类库继承树图；
2. 实现类的时候，只需要关心自己应该实现哪些方法，不必纠结接口要拆得多细才合理，接口由使用方法按需定义，而不用事前规划；
3. 不用为了实现一个接口而导入一个包，因为多引用一个外部包，就意味着更多的耦合，接口使用方按自身需求定义，使用方无需关心是否有其他模块定义过类似的接口。

代码示例，自主实现一个下载https://studygolang.com/网页的代码（其中含有多态的概念）：

main()

package main

import (
    "fmt"
    "interfaceType/mock"
    real2 "interfaceType/real"
)

type Link interface {
    Get(url string) string
}

func download(l Link)string  {
    return l.Get("https://studygolang.com/")
}
func main() {
    var l,m Link
    l = mock.Retriever{"This is a fack link"}
    fmt.Println(download(l))
    m = new(mock.Retriever)
    fmt.Println(download(m))

    var r Link
    r = real2.Retriever{}
    fmt.Println(download(r))
}

mockRetriever

package mock

type Retriever struct {
    Contents string
}

func (r Retriever) Get(url string) string {
    if r.Contents == ""{
        return url
    }
    return r.Contents
}

realRetriever

package real

import (
    "time"
    "net/http"
    "net/http/httputil"
)

type Retriever struct {
    UserAgent string
    TimeOut   time.Duration
}

func (r Retriever) Get(url string) string {
    response, err := http.Get(url)
    if err != nil {
        panic(err)
    }
    result, err := httputil.DumpResponse(response, true)
    if err != nil {
        panic(err)
    }
    defer response.Body.Close()
    return string(result)

}

利用标准库实现下载一个下载https://studygolang.com/网页的代码：

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

// main is the entry point for the application.
func main() {
    // Get a response from the web server.
    r, err := http.Get("https://studygolang.com/")
    if err != nil {
        fmt.Println(err)
        return
    }
    // Copies from the Body to Stdout.
    io.Copy(os.Stdout, r.Body)
    if err := r.Body.Close(); err != nil {
        fmt.Println(err)
    }
}

观察以上代码，不难发现，使用标准库实现网页的download更容易一些当然，我们这里要研究的东西是golang的接口，download的实现是次要的。

r, err := http.Get("https://studygolang.com/")

利用http.Get()函数得到一个http.Response类型的指针，观察一下http.Get()函数源码:

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

在观察一下http.Response：

type Response struct {
    Status     string 
    StatusCode int   
    Proto      string 
    ProtoMajor int   
    ProtoMinor int   
    Header Header
    Body io.ReadCloser
    ContentLength int64
    TransferEncoding []string
    Close bool
    Uncompressed bool
    Trailer Header
    Request *Request
    TLS *tls.ConnectionState
}

原来http.Response是一个结构，不难发现里面的Body是一个io.ReadCloser类型的，让我们再去看看io.ReadCloser的源码：

type ReadCloser interface {
    Reader
    Closer
}

原来Body是一个接口组合，实现了Reader和Closer方法

接下来继续看

io.Copy(os.Stdout, r.Body)

io.Copy()函数的源码：

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

第一个参数是一个Writer，第二个参数是一个Reader，当然，我们的Body实现了Reader这个接口，所以可以直接作为参数传入。

接口赋值

golang接口的赋值有以下两种：

1. 将对象实例赋值给接口：要求该对象实例实现了接口要求的所有方法
2. 将一个接口赋值给另外一个接口：

将实例化对象赋值给接口

package main

import "fmt"

type myInt int
type LessAdd interface {
    Less(b myInt) bool
    Add(b myInt)
}

func main() {
    var a myInt = 2
    var b LessAdd = &a
    b.Add(a)
    fmt.Println(b.Less(0))
    fmt.Printf("%d\n",a)
}
func (a myInt) Less(b myInt) bool {
    return a < b
}
func (a *myInt) Add(b myInt) {
    *a += b
}

有一个有趣的问题：a赋值给接口LessAdd时候，用的是地址的引用，而不是值的引用

    var a myInt = 2
    var b LessAdd = &a

接口LessAdd中包含了一个指针的方法func (a myInt) Add(b myInt)，在调用非指针方法func (a myInt) Less(b myInt) bool时候，golang会自动生成一个函数func(a myInt)Less(b myInt)bool，这就解决了指针传入的问题