Go的接口和其它语言中的方法不一样,它是以使用者为主,先定义接口中需要的方法,再去实现接口中的这些方法

type Inface interface{
  Say(msg string)string
  Name()string
}

我先定义一个接口,我想在这个接口中需要一个函数,我要往这个函数里面传一个string的值,然后返回一个string的值

type Dog struct{
  Name string
}
type Cat struct{
  Name string
}

定义两个接口变量,一个狗,一个猫

// 这里的 Dog 结构体可以使用指针,也可以使用值,使用值可以接收指针和值两种,如果使用指针,那就只能接收指针
func (d *Dog) Say(msg string) string{
  return fmt.Sprintf("%s,%s",d.Name,msg)
}
func (c *Cat) Say(msg string) string{
  return fmt.Sprintf("%s,%s",c.Name,msg)
}

这里是实现接口方法

func main(){
  var inface Inface
  cat:=Cat{"蓝猫"}
  inface=&cat
  ca:=inface.Say("你们好")
  dog:=Dog{"金毛"}
  inface=&dog
  do:=inface.Say("Hello")
  fmt.Println(ca)
  fmt.Println(do)
}

结果

蓝猫,你们好
金毛,Hello

例子2
文件目录

• retriever
  • real
    • retriever.go
  • main.go

// 这个是main.go
package main
import (
    "fmt"
    "retriever/real"

)
type Retriever interface{
  Get(url string) string
}
type download(r Retriever) string{
  return r.Get("http://baidu.com")
}

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

retriever.go 文件

package real
import (
    "net/http"
    "net/http/httputil"
    "time"
)
type Retriever struct{
}
// 这里的 r Retriever 是 Retriever 这个结构体
// 实现接口 Retriever 中的Get方法
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)
}

Go 接口最佳实践（接口组合）

• 倾向于使用小的接口定义, 很多接口只包含一个方法
• 较大的接口定义,可以由多个小接口定义组合而成
• 只依赖于必要功能的最小接口
  例子

// 最小接口
type Reader interface{
  Read(p []byte) (n int, err error)
}
type Writer interface {
  Write(p []byte) (n int, err error)
}
// 大接口,由多个小接口组合
type ReadWriter interface {
  Reader
  Writer
}
// 只用小接口的时候就不用麻烦的调用其它接口
func StoreData(reader Reader) err{
  ...
}

例子2

文件目录

• retriever
  • mock
    • mockretriever.go
  • main.go

package main
type Retriever interface{
  Get(url string) string
}
type Poster interface{
  Post(url string, from map[string] string) string
}
func download(r Retriever)string{
  return r.Get("http://baidu.com")
}
func post(poster Poster){
  poster.Post("http://baidu.com",map[string]string{
    "name":"熊猫拍板砖",
    "contents":"这是我自己定义的命名",
  })
}
type RetrieverPoster interface{
  Retriever
  Poster
}

func session(r RetrieverPoster) string{
  r.Post("http://baidu.com", map[string]string{
    "contents":"another faked aliyun.com",
  })
  r.Get("http://baidu.com")
}

func main(){
  var r Retriever 
  retriever := &mock.Retriever{"this is a fake 熊猫拍板砖"}
  r = retriever
  fmt.Println(download(r))
  fmt.Println(session(retriever))
}

package mock
type Retriever struct{
  Contents string
}

func (r *Retriever) Get(string) string{
  return r.Contents
}
func (r *Retriever) Post(url string, map[string]string)string{
  r.Contents=from["contents"]
  return "ok"
  
}

结果

this is a fake 熊猫拍板砖
another faked aliyun.com

空接口与断言

• 1.空接口可以表示任何类型
• 2. 通过断言来将空接口取出指定的类型
     v,ok :=p.(int) // ok=true 时为取出成功
     p.(int) 这里的p 空接口 int 是要断言的类型

package main

func DoSomething(r interface{}) interface{}{
  switch v:=r{
    case int:
      fmt.Print("int  ")
      return v
    case string:
      fmt.Print("string ")
      return v
  }
}

type slice []interface{}

func main(){
  var b slice
  b=append(b,1)
  b=append(b,"zhangsan")
  b=append(b,2)
  b=append(b,"lisi")
  // 第一种断言方法
  for _,v:=range b{
    fmt.Println(DoSomething(v))
  }
  // 第二种断言方法
  for _,v := range b{
    if j,ok :=v.(int);ok{
      fmt.Println(j)
    }
  }
}

结果

// 第一种结果
int 1
string zhangsan
int 2
string lisi
// 第二种结果
1
2