1.Go的动态类型

接收一个（或多个）接口类型作为参数的函数，其实参可以是任何实现了该接口的类型。 实现了某个接口的类型可以被传给任何以此接口为参数的函数
动态类型（duck typing）

  1. package main
  3. import "fmt"
  5. type IDuck interface {
  6.     Quack()
  7.     Walk()
  8. }
  10. func DuckDance(duck IDuck) {
  11.     for i := 1; i <= 3; i++ {
  12.         duck.Quack()
  13.         duck.Walk()
  14.     }
  15. }
  17. type Bird struct {
  18. }
  20. func (b *Bird) Quack() {
  21.     fmt.Println("I am quacking!")
  22. }
  24. func (b *Bird) Walk() {
  25.     fmt.Println("i am walking")
  26. }
  28. func main() {
  29.     b := &Bird{}
  30.     DuckDance(b)
  31. }

2.动态方法调用

如果方法调用作用于像 interface{} 这样的“泛型”上，你可以通过类型断言（参见 11.3 节）来检查变量是否实现了相应接口。

  1. //例如，你用不同的类型表示 XML 输出流中的不同实体。
  2. //然后我们为 XML 定义一个如下的“写”接口（甚至可以把它定义为私有接口）：
  3. type xmlWriter interface {
  4.     WriteXML(w io.Writer) error
  5. }
  6. //现在我们可以实现适用于该流类型的任何变量的 StreamXML 函数，
  7. //并用类型断言检查传入的变量是否实现了该接口；
  8. //如果没有，我们就调用内建的 encodeToXML 来完成相应工作：
  9. // Exported XML streaming function.
  10. func StreamXML(v interface{}, w io.Writer) error {
  11.     if xw, ok := v.(xmlWriter); ok {
  12.         // It’s an  xmlWriter, use method of asserted type.
  13.         return xw.WriteXML(w)
  14.     }
  15.     // No implementation, so we have to use our own function (with perhaps reflection):
  16.     return encodeToXML(v, w)
  17. }
  19. // Internal XML encoding function.
  20. func encodeToXML(v interface{}, w io.Writer) error {
  21.     // ...
  22. }

3.接口的提取

提取接口 是非常有用的设计模式，可以减少需要的类型和方法数量，而且不需要像传统的基于类的面向对象语言那样维护整个的类层次结构。
所以你不用提前设计出所有的接口；整个设计可以持续演进，而不用废弃之前的决定。类型要实现某个接口，它本身不用改变，你只需要在这个类型上实现新的方法。

4.显式地指明类型实现了某个接口

如果你希望满足某个接口的类型显式地声明它们实现了这个接口，你可以向接口的方法集中添加一个具有描述性名字的方法。例如：

  1. type Fooer interface {
  2.     Foo()
  3.     ImplementsFooer()
  4. }

类型 Bar 必须实现 ImplementsFooer 方法来满足 Footer 接口，以清楚地记录这个事实。

  1. type Bar struct{}
  2. func (b Bar) ImplementsFooer() {}
  3. func (b Bar) Foo() {}

5.空接口和函数重载

在 Go 语言中函数重载可以用可变参数 …T 作为函数最后一个参数来实现（参见 6.3 节）。如果我们把 T 换为空接口，那么可以知道任何类型的变量都是满足 T (空接口）类型的，这样就允许我们传递任何数量任何类型的参数给函数，即重载的实际含义

6.接口的继承

当一个类型包含（内嵌）另一个类型（实现了一个或多个接口）的指针时，这个类型就可以使用（另一个类型）所有的接口方法。
例如：

  1. type Task struct {
  2.     Command string
  3.     *log.Logger
  4. }
  6. //当 log.Logger 实现了 Log() 方法后，Task 的实例 task 就可以调用该方法：
  7. task.Log()

类型可以通过继承多个接口来提供像 多重继承 一样的特性

  1. type ReaderWriter struct {
  2.     *io.Reader
  3.     *io.Writer
  4. }

示例

  1. package main
  3. import "fmt"
  5. type Any interface {
  6. }
  7. type Car struct {
  8.     Model        string
  9.     Manufacturer string
  10.     BuildYear    int
  11. }
  13. type Cars []*Car
  15. //用给定函数f处理所有汽车
  16. func (cs Cars) Process(f func(car *Car)) {
  17.     for _, c := range cs {
  18.         f(c)
  19.     }
  20. }
  22. //找到所有符合给定标准的汽车
  23. func (cs Cars) FindAll(f func(car *Car) bool) Cars {
  24.     cars := make([]*Car, 0)
  26.     cs.Process(func(c *Car) {
  27.         if f(c) {
  28.             cars = append(cars, c)
  29.         }
  30.     })
  31.     return cars
  32. }
  34. //处理汽车并创建新数据
  35. func (cs Cars) Map(f func(car *Car) Any) []Any {
  36.     result := make([]Any, len(cs))
  37.     ix := 0
  38.     cs.Process(func(c *Car) {
  39.         result[ix] = f(c)
  40.         ix++
  41.     })
  42.     return result
  43. }
  45. //
  46. func MakeSortedAppender(manufacturers []string) (func(car *Car), map[string]Cars) {
  47.     //准备排序车的map
  48.     sortedCars := make(map[string]Cars)
  50.     for _, m := range manufacturers {
  51.         sortedCars[m] = make([]*Car, 0)
  52.     }
  53.     sortedCars["Default"] = make([]*Car, 0)
  55.     //准备appender函数
  56.     appender := func(c *Car) {
  57.         if _, ok := sortedCars[c.Manufacturer]; ok {
  58.             sortedCars[c.Manufacturer] = append(sortedCars[c.Manufacturer], c)
  59.         } else {
  60.             sortedCars["Default"] = append(sortedCars["Defaut"], c)
  61.         }
  62.     }
  63.     return appender, sortedCars
  64. }
  66. func main() {
  67.     //make some cars
  68.     ford := &Car{"Fiesta", "Ford", 2008}
  69.     bmw := &Car{"XL 450", "BMW", 2011}
  70.     merc := &Car{"D600", "Mercedes", 2009}
  71.     bwm2 := &Car{"X 800", "BMW", 2008}
  72.     //query
  73.     allCars := Cars([]*Car{ford, bmw, merc, bwm2})
  74.     allNewBmws := allCars.FindAll(func(car *Car) bool {
  75.         return (car.Manufacturer == "BMW") && (car.BuildYear > 2010)
  76.     })
  77.     fmt.Println("AllCars: ", allCars)
  78.     fmt.Println("New BMWs: ", allNewBmws)
  80.     manufacturers := []string{"Ford", "Aston Martin", "Land Rover", "BMW", "Jaguar"}
  81.     sortedAppender, sortedCars := MakeSortedAppender(manufacturers)
  82.     allCars.Process(sortedAppender)
  83.     fmt.Println("Map sortedCars: ", sortedCars)
  84.     BMWCount := len(sortedCars["BMW"])
  85.     fmt.Println("We have ", BMWCount, " BMWs")
  86. }