我们知道，Go 语言从设计伊始，就不支持经典的面向对象语法元素，比如类、对象、继承，等等，但 Go 语言仍保留了名为“方法（method）”的语法元素。当然，Go 语言中的方法和面向对象中的方法并不是一样的。Go 引入方法这一元素，并不是要支持面向对象编程范式，而是 Go 践行组合设计哲学的一种实现层面的需要。
在 Go 编程语言中，方法是与特定类型相关联的函数。它们允许您在自定义类型上定义行为，这个自定义类型可以是结构体（struct）或任何用户定义的类型。方法本质上是一种函数，但它们具有一个特定的接收者（receiver），也就是方法所附加到的类型。这个接收者可以是指针类型或值类型。方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
1.2 声明
Go 语言对 receiver 参数的基类型也有约束，那就是 receiver 参数的基类型本身不能为指针类型或接口类型。
下面的例子分别演示了基类型为指针类型和接口类型时，Go 编译器报错的情况：
type MyInt *int
func (r MyInt) String() string { // r的基类型为MyInt，编译器报错：invalid receiver type MyInt (MyInt is a pointer type)
return fmt.Sprintf("%d", *(*int)(r))
}
type MyReader io.Reader
func (r MyReader) Read(p []byte) (int, error) { // r的基类型为MyReader，编译器报错：invalid receiver type MyReader (MyReader is an interface type)
return r.Read(p)
}
复制代码
1.2.5 方法声明的位置约束
Go 要求，方法声明要与 receiver 参数的基类型声明放在同一个包内。基于这个约束，我们还可以得到两个推论。
第一个推论：我们不能为原生类型（例如 int、float64、map 等）添加方法。例如，下面的代码试图为 Go 原生类型 int 增加新方法 Foo，这是不允许的，Go 编译器会报错：
func (i int) Foo() string { // 编译器报错：cannot define new methods on non-local type int
return fmt.Sprintf("%d", i)
}
复制代码
第二个推论：不能跨越 Go 包为其他包的类型声明新方法。例如，下面的代码试图跨越包边界，为 Go 标准库中的 http.Server 类型添加新方法 Foo，这是不允许的，Go 编译器同样会报错：
import "net/http"
func (s http.Server) Foo() { // 编译器报错：cannot define new methods on non-local type http.Server
}
复制代码
1.2.6 如何使用方法
我们直接还是通过一个例子理解一下。如果 receiver 参数的基类型为 T，那么我们说 receiver 参数绑定在 T 上，我们可以通过 *T 或 T 的变量实例调用该方法：
type T struct{}
func (t T) M(n int) {
}
func main() {
var t T
t.M(1) // 通过类型T的变量实例调用方法M
p := &T{}
p.M(2) // 通过类型*T的变量实例调用方法M
}
复制代码
这段代码中，方法 M 是类型 T 的方法，通过 *T 类型变量也可以调用 M 方法。
二、方法的本质
通过以上，我们知道了 Go 的方法与 Go 中的类型是通过 receiver 联系在一起，我们可以为任何非内置原生类型定义方法，比如下面的类型 T：
type T struct {
a int
}
func (t T) Get() int {
return t.a
}
func (t *T) Set(a int) int {
t.a = a
return t.a
}
复制代码
在Go 中，Go 方法中的原理是将 receiver 参数以第一个参数的身份并入到方法的参数列表中。按照这个原理，我们示例中的类型 T 和 *T 的方法，就可以分别等价转换为下面的普通函数：
// 类型T的方法Get的等价函数
func Get(t T) int {
return t.a
}
// 类型*T的方法Set的等价函数
func Set(t *T, a int) int {
t.a = a
return t.a
}
复制代码
这种等价转换后的函数的类型就是方法的类型。只不过在 Go 语言中，这种等价转换是由 Go 编译器在编译和生成代码时自动完成的。Go 语言规范中还提供了方法表达式（Method Expression）的概念，可以让我们更充分地理解上面的等价转换。
以上面类型 T 以及它的方法为例，结合前面说过的 Go 方法的调用方式，我们可以得到下面代码：
var t T
t.Get()
(&t).Set(1)
复制代码
我们可以用另一种方式，把上面的方法调用做一个等价替换：
var t T
T.Get(t)
(*T).Set(&t, 1)
复制代码
这种直接以类型名 T 调用方法的表达方式，被称为Method Expression。通过Method Expression这种形式，类型 T 只能调用 T 的方法集合（Method Set）中的方法，同理类型 *T 也只能调用 *T 的方法集合中的方法。
我们看到，Method Expression 有些类似于 C++ 中的静态方法（Static Method）。在 C++ 中的静态方法使用时，以该 C++ 类的某个对象实例作为第一个参数。而 Go 语言的 Method Expression 在使用时，同样以 receiver 参数所代表的类型实例作为第一个参数。
这种通过 Method Expression 对方法进行调用的方式，与我们之前所做的方法到函数的等价转换是如出一辙的。所以，Go 语言中的方法的本质就是，一个以方法的 receiver 参数作为第一个参数的普通函数。
而且，Method Expression 就是 Go 方法本质的最好体现，因为方法自身的类型就是一个普通函数的类型，我们甚至可以将它作为右值，赋值给一个函数类型的变量，比如下面示例：
func main() {
var t T
f1 := (*T).Set // f1的类型，也是*T类型Set方法的类型：func (t *T, int)int
f2 := T.Get // f2的类型，也是T类型Get方法的类型：func(t T)int
fmt.Printf("the type of f1 is %T\n", f1) // the type of f1 is func(*main.T, int) int
fmt.Printf("the type of f2 is %T\n", f2) // the type of f2 is func(main.T) int
