关于鸭子类型

首先我们定义一个规范，也就是说定义一个接口：

type Duck interface {
    Quack()   // 鸭子叫
    DuckGo()  // 鸭子走
}
这个接口是鸭子的行为，我们认为，作为一只鸭子，它需要会叫，会走。然后我们再定义一只鸡：

type Chicken struct {
}
假设这只鸡特别厉害，它也会像鸭子那样叫，也会像鸭子那样走路，那么我们定义一下这只鸡的行为：

func (c Chicken) Quack() {
    fmt.Println("嘎嘎")
}

func (c Chicken) DuckGo() {
    fmt.Println("大摇大摆的走")
}。
*注意，这里只是实现了 Duck 接口方法，并没有将鸡类型和鸭子接口显式绑定。这是一种非侵入式的设计。
然后我们让这只鸡，去叫，去像鸭子那样走路：

func main() {
    c := Chicken{}
    var d Duck
    d = c
    d.Quack()
    d.DuckGo()   # 这一点目前有点疑问，关于接口可以先参照下面的题外话代码
}
执行之后我们可以得到结果：

嘎嘎
大摇大摆的走

这里 go 的 
func (c Chicken) DuckGo()
func (c Chicken) Quack()
两个函数可以看成是Python中的方法，go利用接口 type Duck interface 实现了go中的多态，如果没有这个interface的存在，可以看出 一个函数的方法，必须要指定入参的类型，例如func (c Chicken) Quack()，指定了这个入参是Chicken类型的，

如果传入其它的，当然就会编译报错
例：

type Vertex struct {
   X, Y float64
}

type Vertex2 struct {
   X, Y float64
}

func (v *Vertex) test(){
   v.X++;
   v.Y++;
}

func main(){
　　v2 := Vertex2{2,3}
　　v2.test()
}

# awesomeProject
.\test.go:77:3: v.test2 undefined (type Vertex2 has no field or method test)

package main

import (
    "fmt"
    "math"
)

type geometry interface {
    area() float64
    perim() float64
}

type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

func measure(g geometry) {            # 这里才体现出了接口的作用，入参统一为geometry，所以下面↓
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)                        # 这里这里，r和c不是同一个结构体对象，但是可以同时作为入参使用measure函数，并且满足在measure中的g.area()和g.perim()方法
    measure(c)
}