接口

  • 接口关注于类型可以做什么，而不是存储了什么。
  • 接口通过列举类型必须满足的一组方法来进行声明。
  • 在 Go 语言中，不需要显式声明接口。
  • 任何类型的任何值，只要它满足了接口的要求，就能够成为变量t的值 
  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6. )
  8. type martian struct{}
  10. func (m martian) talk() string {
  11.     return "nack nack"
  12. }
  14. type laser int
  16. func (l laser) talk() string {
  17.     return strings.Repeat("pew ", int(l))
  18. }
  20. func main() {
  21.     var t interface {
  22.         talk() string
  23.     }
  25.     t = martian{}
  26.     fmt.Println(t.talk())
  28.     t = laser(3)
  29.     fmt.Println(t.talk())
  30. }

接口类型

  • 为了复用，通常会把接口声明为类型。
  • 按约定，接口名称通常以 er 结尾。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6. )
  8. type martian struct{}
  10. func (m martian) talk() string {
  11.     return "nack nack"
  12. }
  14. type laser int
  16. func (l laser) talk() string {
  17.     return strings.Repeat("pew ", int(l))
  18. }
  20. type talker interface {
  21.     talk() string
  22. }
  24. func shout(t talker) {
  25.     louder := strings.ToUpper(t.talk())
  26.     fmt.Println(louder)
  27. }
  29. func main() {
  30.     shout(martian{})
  31.     shout(laser(2))
  33.     type crater struct{}
  34.     // crater does not implement talker (missing talk method)
  35.     // shout(crater{})
  36. }
  • 接口可以与 struct 嵌入 特性一同使用。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6. )
  8. type laser int
  10. func (l laser) talk() string {
  11.     return strings.Repeat("pew ", int(l))
  12. }
  14. type talker interface {
  15.     talk() string
  16. }
  18. func shout(t talker) {
  19.     louder := strings.ToUpper(t.talk())
  20.     fmt.Println(louder)
  21. }
  23. func main() {
  24.     type starship struct {
  25.         laser
  26.     }
  28.     s := starship{laser(3)}
  30.     fmt.Println(s.talk())
  31.     shout(s)
  32. }
  • 同时使用组合和接口将构成非常强大的设计工具。

探索接口

  • Go 语言的接口都是隐式满足的。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. type stardater interface {
  9.     YearDay() int
  10.     Hour() int
  11. }
  13. // stardate returns a fictional measure of time.
  14. func stardate(t stardater) float64 {
  15.     doy := float64(t.YearDay())
  16.     h := float64(t.Hour()) / 24.0
  17.     return 1000 + doy + h
  18. }
  20. type sol int
  22. func (s sol) YearDay() int {
  23.     return int(s % 668)
  24. }
  26. func (s sol) Hour() int {
  27.     return 0
  28. }
  30. func main() {
  31.     day := time.Date(2012, 8, 6, 5, 17, 0, 0, time.UTC)
  32.     fmt.Printf("%.1f Curiosity has landed\n", stardate(day))
  34.     s := sol(1422)
  35.     fmt.Printf("%.1f Happy birthday\n", stardate(s))
  36. }

满足接口

  • Go 标准库导出了很多只有单个方法的接口。
  • Go 通过简单的、通常只有单个方法的接口……来鼓励组合而不是继承，这些接口在各个组件之间形成了简明易懂的界限。
    —— Rob Pike
  • 例如 fmt 包声明的 Stringer 接口：

接口 - 图1 

  1. package main
  3. import "fmt"
  5. // location with a latitude, longitude in decimal degrees.
  6. type location struct {
  7.     lat, long float64
  8. }
  10. // String formats a location with latitude, longitude.
  11. func (l location) String() string {
  12.     return fmt.Sprintf("%v, %v", l.lat, l.long)
  13. }
  15. func main() {
  16.     curiosity := location{-4.5895, 137.4417}
  17.     fmt.Println(curiosity)
  18. }
  • 标准库中常用接口还包括：io.Reader，io.Writer，json.Marshaler…

作业题

  • 基于刚才小测试的答案，扩展并编写一个用 JSON 格式输出坐标的程序。这个程序的 JSON 输出应该分别用十进制（DD）和度/分/秒（DMS）两种格式提供坐标：

接口 - 图2

  • 通过满足定制 JSON 数据的 json.Marshaler 接口，你应该无需修改坐标结构就能够达到上述目的。在编写 MarshalJSON 方法的时候可以考虑使用 json.Marshal 函数。
  • 可以使用 22 章介绍过的 decimal 方法
  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     "os"
  7. )
  9. // coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
  10. type coordinate struct {
  11.     d, m, s float64
  12.     h       rune
  13. }
  15. // String formats a DMS coordinate.
  16. func (c coordinate) String() string {
  17.     return fmt.Sprintf("%vº%v'%.1f\" %c", c.d, c.m, c.s, c.h)
  18. }
  20. // decimal converts a d/m/s coordinate to decimal degrees.
  21. func (c coordinate) decimal() float64 {
  22.     sign := 1.0
  23.     switch c.h {
  24.     case 'S', 'W', 's', 'w':
  25.         sign = -1
  26.     }
  27.     return sign * (c.d + c.m/60 + c.s/3600)
  28. }
  30. func (c coordinate) MarshalJSON() ([]byte, error) {
  31.     return json.Marshal(struct {
  32.         DD  float64 `json:"decimal"`
  33.         DMS string  `json:"dms"`
  34.         D   float64 `json:"degrees"`
  35.         M   float64 `json:"minutes"`
  36.         S   float64 `json:"seconds"`
  37.         H   string  `json:"hemisphere"`
  38.     }{
  39.         DD:  c.decimal(),
  40.         DMS: c.String(),
  41.         D:   c.d,
  42.         M:   c.m,
  43.         S:   c.s,
  44.         H:   string(c.h),
  45.     })
  46. }
  48. // location with a latitude, longitude in decimal degrees.
  49. type location struct {
  50.     Name string     `json:"name"`
  51.     Lat  coordinate `json:"latitude"`
  52.     Long coordinate `json:"longitude"`
  53. }
  55. func main() {
  56.     elysium := location{
  57.         Name: "Elysium Planitia",
  58.         Lat:  coordinate{4, 30, 0.0, 'N'},
  59.         Long: coordinate{135, 54, 0, 'E'},
  60.     }
  62.     bytes, err := json.MarshalIndent(elysium, "", "  ")
  63.     if err != nil {
  64.         fmt.Println(err)
  65.         os.Exit(1)
  66.     }
  68.     fmt.Println(string(bytes))
  69. }