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)
}