携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第12天，点击查看活动详情

接口

接口类型是由一组方法签名定义的集合。接口类型的变量可以保存任何实现了这些方法的值（如下例中的a）。

package main

import (
   "fmt"
   "math"
)

type Abser2 interface {
   Abs2() float64
}

type MyFloat2 float64

type Vertex2 struct {
   X, Y float64
}

func (f MyFloat2) Abs2() float64 {
   if f < 0 {
      return float64(-f)
   }
   return float64(f)
}

func (v *Vertex2) Abs2() float64 {
   return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
   var a Abser2
   f := MyFloat2(-math.Sqrt2)
   v := Vertex2{3, 4}
   a = f
   a = &v
   //错误，Abs2()只接收了*Vertex2而非Vertex2
   //a = v

   fmt.Println(a.Abs2())
}

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有“implements”关键字。隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。自下而上的抽象更加方便了。

package main

import "fmt"

type I interface {
   M()
}

type T struct {
   S string
}

//此方法表示类型T实现了接口I，但我们无需显式声明此事。
func (t T) M() {
   fmt.Println(t.S)
}

func main() {
   var i I = T{"hello"}
   i.M()
}

接口值

接口也是值。它们可以像其它值一样传递。接口值可以用作函数的参数或返回值。

在内部，接口值可以看做包含值和具体类型的元组：
(value,type)

接口值保存了一个具体底层类型的具体值。接口值调用方法时会执行其底层类型的同名方法。

package main

import (
   "fmt"
   "math"
)

type I1 interface {
   M()
}

type T1 struct {
   S string
}

func (t *T1) M() {
   fmt.Println(t.S)
}

func (t T1) N() {
   fmt.Println("t.S")
}

type F float64

func (f F) M() {
   fmt.Println(f)
}

func main() {
   var i I1
   i = &T1{"Hello"}
   descirbe(i)
   i.M()

   i = F(math.Pi)
   descirbe(i)
   i.M()
}

func descirbe(i I1) {
   fmt.Printf("(%v, %T)\n", i, i)
}

底层值为nil的接口值

即便接口内的具体值为nil，方法仍然会被nil接收者调用。

在一些语言中，这会触发一个空指针异常，但在Go中通常会写一些优雅地处理它（如本例中的M方法）。

注意： 保存了nil具体值的接口其自身并不为nil。

package main

import "fmt"

type I2 interface {
   M()
}

type T2 struct {
   S string
}

func (t *T2) M() {
   if t == nil {
      fmt.Println("<nil>")
      return
   }
   fmt.Println(t.S)
}

func main() {
   var i I2
   var t *T2
   //接口内的具体值为nil
   i = t
   describe(i)
   i.M()

   i = &T2{"hello"}
   describe(i)
   i.M()
}

func describe(i I2) {
   fmt.Printf("(%v, %T)\n", i, i)
}

nil接口值

nil接口值既不保存值也不保存具体类型。

为nil接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个 具体 方法的类型。

package main

import "fmt"

type I3 interface {
   M()
}

func main() {
   var i I
   decribe(i)
   i.M()
}

func decribe(i I) {
   fmt.Printf("(%v,%T)\n", i, i)
}

空接口

指定了零个方法的接口值被称为空接口：
interface{}

空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）

空接口被用来处理未知类型的值。例如，fmt.Print可接受类型为intereface{}的任意数量的参数。

package main

import "fmt"

func main() {
   var i interface{}
   decribe1(i)

   i = 42
   decribe1(i)

   i = "hello"
   decribe1(i)
}

func decribe1(i interface{}) {
   fmt.Printf("(%v, %T)\n", i, i)
}

输出

(<nil>, <nil>)
(42, int)
(hello, string)

类型断言

类型断言，提供了访问接口底层具体值的方式。
t :=i.(T) 该语句断言接口值i保存了具体类型T，并将其底层类型为T的值赋予变量t。

若i并未保存T类型的值，该语句就会触发一个恐慌（panic）。

为了判断一个接口值是否保存了一个特定的类型，类型断言可以返回两个值：
t,ok := i.(T)

增加了一个ok bool值表示断言是否成功，如果不成功返回false，t返回该类型的默认值。这样当false的时候就不会发生恐慌。

package main

import "fmt"

func main() {
   var i interface{} = "hello"
   s := i.(string)
   fmt.Println(s)

   s, ok := i.(string)
   fmt.Println(s, ok)

   f, ok := i.(float64)
   fmt.Println(f, ok)

   f = i.(float64) //报错 pannic
   fmt.Println(f)
}

类型选择

类型选择 是按顺序从几个类型断言中选择分支的结构。使用switch和类型断言，只不过断言的类型不是具体的类型而变成关键字type，case判断变成具体的类型，如下：

package main

import "fmt"

func do(i interface{}) {
   switch v := i.(type) {
   case int:
      fmt.Printf("Twice %v is %v\n", v, v*2)
   case string:
      fmt.Printf("%q is %v bytes long\n", v, len(v))
   default:
      fmt.Printf("I don't konw about type %T!\n", v)
   }
}

func main() {
   do(21)
   do("hello")
   do(true)
}

Stringer

fmt包中定义的Stringer是最普遍的接口之一：

type Stringer interface {
    String() string
}

Stringer是一个可以用字符串描述自己的类型。

package main

import "fmt"

type Person struct {
   Name string
   Age  int
}

func (p Person) String() string {
   return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}

func main() {
   a := Person{"Arthur Dent", 42}
   z := Person{"Zaphod Beeblebrox", 9001}
   fmt.Println(a, z)
}

类似于java的默认继承类Object的toString方法，java默认全类名和hash，go默认打印具体值，这点比java方便

练习Stringer

给 IPAddr 添加一个 "String() string" 方法

package main

import "fmt"

type IPAddr [4]byte

// 给 IPAddr 添加一个 "String() string" 方法
func (ip IPAddr) String() string {
   var s string
   for i := 0; i < len(ip); i++ {
      if i == (len(ip) - 1) {
         s = fmt.Sprintf("%v%v", s, ip[i])
      } else {
         s = fmt.Sprintf("%v%v.", s, ip[i])
      }
   }
   return s
}

func main() {
   hosts := map[string]IPAddr{
      "loopback":  {127, 0, 0, 1},
      "googleDNS": {8, 8, 8, 8},
   }
   for name, ip := range hosts {
      fmt.Printf("%v: %v\n", name, ip)
   }
}

error

Go程序使用error值来表示错误状态。 与fmt.Stringer类似，error类型是一个内建接口：

type error interface {
    Error() string
}

通常函数会返回一个error值，调用它的代码应当判断这个错误是否等于nil进行错误处理，error为nil表示成功，非nil表示失败：

package main

import (
   "fmt"
   "time"
)

type MyError struct {
   When time.Time
   What string
}

func (e *MyError) Error() string {
   return fmt.Sprintf("at %v,%s", e.When, e.What)
}

func run() error {
   return &MyError{
      time.Now(),
      "it didn't work",
   }
}
func main() {
   if err := run(); err != nil {
      fmt.Println(err)
   }
}

练习error

Sqrt 接受到一个负数时，应当返回一个非 nil 的错误值。复数同样也不被支持。

创建一个新的类型

type ErrNegativeSqrt float64

并为其实现

func (e ErrNegativeSqrt) Error() string

方法使其拥有 error 值，通过 ErrNegativeSqrt(-2).Error() 调用该方法应返回 "cannot Sqrt negative number: -2"

package main

import (
   "fmt"
   "math"
)

type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {
   return fmt.Sprintf("cannot Sqrt negative number:%v", e)
}

func Sqrt(x float64) (float64, error) {
   if x < 0 {
      return 0, ErrNegativeSqrt(x)
   }
   return math.Sqrt(x), nil
}

func main() {
   fmt.Println(Sqrt(2))
   fmt.Println(Sqrt(-2))
}

return fmt.Sprintf("cannot Sqrt negative number:%v", e)会出现无限循环，具体看调用栈即可。改成return fmt.Sprintf("cannot Sqrt negative number:%v", float64(e))

Reader

io包指定了io.Reader接口，它表示从数据流的末尾进行读取。 Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。

io.Reader接口有一个Read方法：

func (T) Read(b []byte) (n int, err error)

Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。

package main

import (
   "fmt"
   "io"
   "strings"
)

func main() {
   r := strings.NewReader("Hello,Reader!")
   b := make([]byte, 8)
   for {
      n, err := r.Read(b)
      fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
      fmt.Printf("b[:n] = %q\n", b[:n])
      if err == io.EOF {
         break
      }
   }
}

图像

image包定义了Image接口：

package image

type Image interface {
    ColorModel() color.Model
    Bounds() Rectangle
    At(x, y int) color.Color
}

例子

package main

import (
   "fmt"
   "image"
)

func main() {
   m := image.NewRGBA(image.Rect(0, 0, 100, 100))
   fmt.Println(m.Bounds())
   fmt.Println(m.At(0, 0).RGBA())
}