方法声明

写一个简单的方法：

type Point struct{X, Y float64}

// 普通的函数
func Distance(p, q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// 同样的作用，用方法实现
func (p Point) Distance(q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

接收者：附加的参数 p 称为方法的接收者。
调用方法的时候，接收者在方法名的前面。这样就和声明保持一致：

p := Point{1, 2}
q := Point{4, 6}
fmt.Println(Distance(p, q)) // 函数调用
fmt.Println(p.Distance(q))  // 方法调用

选择子：表达是 p.Distance 称作选择子（selector），因为它为接收者 p 选择合适的 Distance 方法。

指针接收者的方法

对于函数，它会复制每一只实参变量。如果函数需要更新一个变量，或者是因为实参太大而需要避免复制整个实参，就需要使用指针来传递变量的地址。
对于方法的接受者，也可以将方法绑定到指针类型。习惯上遵循如果一个类型的任何一个方法使用指针接收者，那么所有该类型的方法都应该使用指针接收者，即使有些方法不一定需要。
另外，为了防止混淆，不允许本身是指针的类型进行方法声明，会有编译错误：

type p *int
func (p) f() { /*...*/ } // 编译错误：非法的接收者类型

方法变量与表达式

方法变量（method value）

通常是在相同的表达式里使用和调用方法，但是把两个操作分开也是可以的。选择子 p.Distance 可以赋予一个方法变量，它是一个函数，把方法(Point.Distance)绑定到一个接收者 p 上。函数只需要提供实参而不需要提供接收者就能够调用：

p := Point{1, 2}
q := Point{4, 6}
distanceFromP := p.Distance // 方法变量
fmt.Println(distanceFromP(q))

这里 p.Distance 是选择子，把它赋值给变量 distanceFromP，这个变量就是方法变量，并且这个变量是一个函数。
如果包内的 API 调用一个函数值，并且使用者期望这个函数的行为是调用一个特定接收者的方法，方法变量就非常有用。使用方法变量还可以是代码更加简洁：

type Rocket struct { /* ... */ }
func (r *Rocket) Launch() { /* ... */ }

r := new(Rocket)
time.AfterFunc(10 * time.Second, func() { r.Launch() }) // 如果没有方法变量，那么要把执行一个方法包在一个函数里，等到函数被调用后执行
time.AfterFunc(10 * time.Second, r.Launch)  // 使用方法变量，这里 r.Launch 就是一个函数，只是没有赋值给某个变量，没有函数名

函数 time.AfterFunc 的作用是在指定的延迟后调用一个函数。上面说了，方法变量也是函数。

方法表达式（method expression）

调用方法的时候必须提供接收者，并且按照选择子的语法进行调用。
方法表达式，写成 T.f 或者 (*T.f)。
其中 T 是类型，是一种函数变量，把原来方法的接收者替换成函数的第一个形参，因此它可以像平常的函数一样调用：

p := Point{1, 2}
q := Point{4, 6}
distance :=  Point.Distance  // 方法表达式
fmt.Println(distance(p, q))
fmt.Printf("%T\n", distance) // "func(Point, Point) float64"

如果需要一个值来代表多个方法中的一个，而方法都属于同一个类型，方法表达式可以实现让这个值所对应的方法来处理不同的接收者。就是可以把一个方法变成一个函数，函数的变量会增加一个，第一个变量就是原来方法中的接收者。其实各个参数的顺序还是一样的，原本第一个参数在 func 前，现在移动到了 func 后面。 p.Distance(q) 变成了 distance(p, q)。

接口类型

io包定义了很多有用的接口：

io.Writer ：抽象了所有写入字节的类型，下面会列举
io.Reader ：抽象了所有可以读取字节的类型
io.Closer ：抽象了所有可以关闭的类型，比如文件或者网络连接

io.Writer 是一个广泛使用的接口，它负责所有可以写入字节的抽象，包括但不限于下面列举的这些：

文件
内存缓冲区
网络连接
HTTP客户端
打包器（archiver）
散列器（hasher）

接口值

接口值，就是一个接口类型的值。分两个部分：

动态类型 ：该接口的具体类型
动态值 ：该具体类型的一个值

var w io.Writer  // 声明接口，动态类型和动态值都是nil
w = os.Stdout  // 有动态类型，也有动态值
w = io.Writer(os.Stdout)  // 和上面这句等价，把一个具体类型显式转换为接口类型
w = new(bytes.Buffer)  // 有动态类型，也有动态值
w = nil  // 把动态类型和动态值都设置为nil，恢复到声明时的状态

比较接口值

接口值可以用 == 和 != 来比较。动态类型一致，然后动态值相等（使用动态类型的 == 来比较），那么接口值相等。接口值都是nil也是相等的。
可以作为map的key，也可以作为switch语句的操作数，因为可以比较。
动态值可能是不可比较的类型，比如切片。对这样的接口进行比较，就会Panic。把这样的接口用作map的key或者switch语句的操作数时也同样会Panic。所以，仅在能确认接口值包含的动态值可以比较时，才比较接口值。
fmt 包的 %T 打印出来的就是动态类型。在内部实现中，fmt 用反射来拿到接口动态类型的名字。

注意：含有空指针的非空接口

空的接口值（动态类型和动态值都为空）和仅仅动态值为nil的接口值是不一样的。

const debug = true

func main() {
    var buf *bytes.Buffer
    if debug {
        buf = new(bytes.Buffer)
    }
    f(buf)
    if debug {
        // ...使用 buf...
    }
}

// 如果 out 不是 nil，那么会向其写入输出的数据
func f(out io.Writer) {
    // ...其他代码...
    if out != nil {
        out.Write([]byte("done\n"))
    }
}

这里，把一个类型为 *bytes.Buffer 的空指针赋给了 out 参数，此时 out 的动态值为空。但它的动态类型是 *bytes.Buffer。就是说 out 是一个包含空指针的非空接口，所以这里的检查 out != nil 是 true，防御不了这种情况。
对于某些类型，比如 *os.File，空接收值是合法的。但是对于这里的 *buyes.Buffer，要求接收者不能为空，于是运行时会Panic。
这里的解决方案是，把 main 函数中的 buf 类型修改为 io.Writer，从而避免在最开始就把一个功能不完整的值赋给一个接口：

var buf io.Writer
if debug {
    buf = new(bytes.Buffer)
}
f(buf)

类型断言

类型断言是一个作用在接口值上的操作，代码类似于x(T)，x是一个接口类型的表达式，而T是一个类型（称为断言类型）。类型断言会检查操作数的动态类型是否满足指定的断言类型。
这里有两种可能：

断言类型T是一个具体类型
断言类型T是一个接口类型

具体类型
如果断言类型T是一个具体类型，断言类型会检查x的动态类型是否就是T。如果检查成功，返回x的动态值，返回的类型就是T。如果检查失败，那么操作崩溃。

接口类型
如果断言类型T是一个接口类型，断言类型会检查x的动态类型是否满足T。如果检查成功，动态值并没有提取出来，仍然是一个接口值，接口值的类型和值部分也不会变，只是结果类型为接口类型T。就是说，这里类型断言就是一个接口值表达式，从一个接口类型变为拥有另外一套方法的接口类型，但保留了接口值中动态类型和动态值部分。如果检查失败还是会崩溃。

类型断言可以返回两个结果，此时操作不会因为检查失败而崩溃。多出来的返回值是一个布尔型，用来指示断言是否成功。按照惯例，一般变量名用ok。如果操作失败，ok为false，而第一个返回值会是断言类型的零值。

类型分支

接口有两种不同的风格。
第一种风格下，典型的比如：io.Reader、io.Writer、fmt.Stringer、sort.Interface、http.Handler 和 error。接口上的各种方法突出了满足这个接口的具体类型之间的相似性，但隐藏了各个具体类型的布局和各自特有的功能。这种风格强调了方法，而不是具体类型。
第二种风格则充分利用了接口值能够容纳各种具体类型的能力，它把接口作为这些类型的联合（union）来使用。类型断言用来在运行时区分这些类型并分别处理。这这种风格中，强调的是满足这个接口的具体类型，而不是这个接口的方法（经常是没变方法的空接口），也不注重信息隐藏。这种风格的接口使用方式称为可识别联合（discriminated union）。
如果对面向对象熟悉，这两种风格分别对应：

子类型多态（subtype polymorphism）
特设多态（ad hoc polymorphism）

使用接口的一些建议

不要一开始就定义接口，每个接口却只是一个单独的实现。这种接口是不必要的抽象，还会有运行时的成本。仅在有两个或多个具体类型需要按统一的方式处理时才需要接口。
上面的建议也有特例，如果接口和类型实现出于依赖的原因不能放在同一个包里边，那么一个接口只有一个具体类型实现也是可以的。在这种情况下，接口是一种解耦两个包的好方式。

来源：oschina

链接：https://my.oschina.net/u/4310671/blog/4318663

标签

Hasher

gopl 方法和接口