square-gopher.png

在 go 语言接口更重视使用者，使用者是否承认和使用接口才是重要的，这里定义 Retriever 接口提供 Get 方法，所有具有 Get 方法的都可以认为是接口

package main

import (
    "fmt"
    "com.zidea/util/mock"
)

type Retriever interface{
    Get(url string) string
}

func download(r Retriever) string {
    return r.Get("www.baidu.com")
}

func main()  {
    var r Retriever
    r = mock.Retriever{"this is fake baidu com"}
    fmt.Println(download(r))
}

func main()  {
    var r Retriever
    r = real.Retriever{}
    fmt.Println(download(r))
}

定义了download方法接受接口Retriever类型的参数，然后调用接口的 Get 方法来获取网络资源，那么download无疑就是使用者，只要使用者认为接受参数是Retriever那么就是Retriever，也就是站在使用者角度来审视接口，例如一个需要吃的人认为烤鸭才是他想要的鸭子

20120317151833841.jpg

而一个小朋友认为玩具鸭子才是他想要的鸭子。

接口的值类型

在其他语言中这里 r 可能只是真实的 Retriever 的引用，但是在 go 语言中所有的类型都是值类型，所以 r 还是有内容的。

在 interface 中是有两个东西类型和值，这里我们可以通过引用和值形式来实现接口，我们通过打印来看一下接口到底是什么东西，%T 代表类型 %V 代表值，这里分别打印出两种

r = mock.Retriever{"this is a fake baidu com"}
    fmt.Printf("%T %v\n",r,r) // mock.Retriever {this is a fake baidu com}
r = real.Retriever{}
fmt.Printf("%T %v\n",r,r) // real.Retriever { 0s} // userAgent 是空格， timer 是 0s

我们可以修改为接受者（接口）为引用而非值的形式

r = &real.Retriever{
        UserAgent:"Mozilla/5.0",
        Timeout: time.Minute,
    }
    fmt.Printf("%T %v\n",r,r) // real.Retriever { 0s} // userAgent 是空格， timer 是 0s

func (r *Retriever) Get (url string) string {
    resp, err := http.Get(url)
    if err != nil{
        panic(err)
    }

    result, err := httputil.DumpResponse(
        resp, true)
    resp.Body.Close()
    if err != nil {
        panic(err)
    }

    return string(result)
}

r = &real.Retriever{
        UserAgent:"Mozilla/5.0",
        Timeout: time.Minute,
    }

现在 r 是一个指针，如果是一个真实的值就是 copy，如果

mock.Retriever {this is a fake baidu com}
*real.Retriever &{Mozilla/5.0 1m

既然我们知道接口中有类型，我们怎么知道类型，通过.type 来获得类型，

func inspect(r Retriever){
    switch v := r.(type) {
    case mock.Retriever:
        fmt.Println("Contents:",v.Contents)
    case *real.Retriever:
        fmt.Println("UserAgent",v.UserAgent)
    }
}

inspect(r)

我们通过 type 就可以知道是什么类型

// Type assertion
    realRetriever := r.(*real.Retriever)
    fmt.Println(realRetriever.Timeout)

通过.获取r的类型

panic: interface conversion: main.Retriever is mock.Retriever, not *mock.Retriever

if mockRetriever, ok := r.(mock.Retriever); ok{
        fmt.Println(mockRetriever.Contents)
    }else{
        fmt.Println(" not a mock retriever ")
    }

接口变量

• 实现者的类型
• 实现者的值(或实现者的指针)

接口变量里面有什么

• 接口变量自带指针
• 接口变量同样采用值传递，几乎不需要使用接口的指针
• 指针接收者实现只能以指针方式使用; 值接收都可

查看接口变量

• 表示任何类型:interface{}
• Type Assertion
• Type Switch

package queue

type Queue []int

func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

func (q *Queue) IsEmpty() bool  {
    return len(*q) == 0
}

q := queue.Queue{1}

    q.Push(2)
    q.Push(3)
    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())

golang.jpg

我们这里通过修改这个 queue 类了解一下 interface{} 这个表示任何类型的接口。下面简单举个实例看一下 interface{} 接口, interface{} 可以说是无可不能，代替一切类型，同时也就没有任何意义

type Queue []interface{}

func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

func (q *Queue) Pop() interface{} {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

func (q *Queue) IsEmpty() bool  {
    return len(*q) == 0
}

q.Push(2)
    q.Push(3)
    q.Push("abc")
    fmt.Println(q.Pop())
    fmt.Println(q.IsEmpty())

func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head.(int)
}

这时我们就会在编译时出现错误

.\main.go:55:9: cannot use "abc" (type string) as type int in argument to q.Push

func (q *Queue) Push(v interface{}) {
    *q = append(*q, v.(int))
}

func (q *Queue) Pop() interface{} {
    head := (*q)[0]
    *q = (*q)[1:]
    return head.(int)
}