方法

1. T必须是一个定义类型；
2. T必须和此方法声明定义在同一个代码包中；
3. T不能是一个指针类型；
4. T不能是一个接口类型。接口类型将在下一篇文章中讲解。

类型T和*T称为它们各自的方法的属主类型（receiver type）。 类型T被称作为类型T和*T声明的所有方法的属主基类型（receiver base type）。

注意：我们也可以为满足上列条件的类型T和*T的别名声明方法。 这样做的效果和直接为类型T和*T声明方法是一样的。

如果我们为某个类型声明了一个方法，以后我们可以说此类型拥有此方法。

从上面列出的条件，我们得知我们不能为下列类型（显式地）声明方法：

• 内置基本类型。比如int和string。 因为这些类型声明在内置builtin标准包中，而我们不能在标准包中声明方法。
• 接口类型。但是接口类型可以拥有方法。详见下一篇文章。
• 除了满足上面条件的形如*T的指针类型之外的非定义组合类型。

一个方法声明和一个函数声明很相似，但是比函数声明多了一个额外的参数声明部分。 此额外的参数声明部分只能含有一个类型为此方法的属主类型的参数，此参数称为此方法声明的属主参数（receiver parameter）。 此属主参数声明必须包裹在一对小括号()之中。 此属主参数声明部分必须处于func关键字和方法名之间。

下面是一个方法声明的例子：

// Age和int是两个不同的类型。我们不能为int和*int
// 类型声明方法，但是可以为Age和*Age类型声明方法。
type Age int
func (age Age) LargerThan(a Age) bool {
    return age > a
}
func (age *Age) Increase() {
    *age++
}

// 为自定义的函数类型FilterFunc声明方法。
type FilterFunc func(in int) bool
func (ff FilterFunc) Filte(in int) bool {
    return ff(in)
}

// 为自定义的映射类型StringSet声明方法。
type StringSet map[string]struct{}
func (ss StringSet) Has(key string) bool {
    _, present := ss[key]
    return present
}
func (ss StringSet) Add(key string) {
    ss[key] = struct{}{}
}
func (ss StringSet) Remove(key string) {
    delete(ss, key)
}

// 为自定义的结构体类型Book和它的指针类型*Book声明方法。
type Book struct {
    pages int
}
func (b Book) Pages() int {
    return b.pages
}
func (b *Book) SetPages(pages int) {
    b.pages = pages
}

从上面的例子可以看出，我们可以为各种种类（kind）的类型声明方法，而不仅仅是结构体类型。

在很多其它面向对象的编程语言中，属主参数名总是为隐式声明的this或者self。这样的名称不推荐在Go编程中使用。

指针类型的属主参数称为指针类型属主，非指针类型的属主参数称为值类型属主。 在大多数情况下，我个人非常反对将指针和值这两个术语用做对立面，但是在这里，我并不反对这么用，原因将在下面谈及。

func Book.Pages(b Book) int {
    return b.pages // 此函数体和Book类型的Pages方法体一样
}

func (*Book).SetPages(b *Book, pages int) {
    b.pages = pages // 此函数体和*Book类型的SetPages方法体一样
}

在上面的两个隐式函数声明中，它们各自对应的方法声明的属主参数声明被插入到了普通参数声明的第一位。 它们的函数体和各自对应的显式方法的方法体是一样的。

两个隐式函数名Book.Pages和(*Book).SetPages都是aType.MethodName这种形式的。
我们不能显式声明名称为这种形式的函数，因为这种形式不属于合法标识符。这样的函数只能由编译器隐式声明。
但是我们可以在代码中调用这些隐式声明的函数：

package main

import "fmt"

type Book struct {
    pages int
}
func (b Book) Pages() int {
    return b.pages
}
func (b *Book) SetPages(pages int) {
    b.pages = pages
}

func main() {
    var book Book
    // 调用这两个隐式声明的函数。
    (*Book).SetPages(&book, 123)
    fmt.Println(Book.Pages(book)) // 123
}

事实上，在隐式声明上述两个函数的同时，编译器也将改写这两个函数对应的显式方法（至少，我们可以这样认为），让这两个方法在体内直接调用这两个隐式函数：

func (b Book) Pages() int {
    return Book.pages(b)
}
func (b *Book) SetPages(pages int) {
    (*Book).SetPages(b, pages)
}

func (b *Book) Pages() int {
    return Book.Pages(*b) // 调用上节中隐式声明的函数
}

正因为如此，我并不排斥使用值类型属主这个术语做为指针类型属主这个术语的对立面。 毕竟，当我们为一个非指针类型显式声明一个方法的时候，事实上两个方法被声明了。 一个方法是为非指针类型显式声明的，另一个是为指针类型隐式声明的。

上一节已经提到了，每一个方法对应着一个编译器隐式声明的函数。
所以对于刚提到的隐式方法，编译器也将隐式声明一个相应的函数：

func (*Book).Pages(b *Book) int {
    return Book.Pages(*b)
}

换句话说，对于每一个为值类型属主显式声明的方法，同时将有一个隐式方法和两个隐式函数被自动声明。

一个方法原型可以看作是一个不带func关键字的函数原型。 我们可以把每个方法声明看作是由一个func关键字、一个属主参数声明部分、一个方法原型和一个方法体组成。

比如，上面的例子中的Pages和SetPages的原型如下：

Pages() int
SetPages(pages int)

每个类型都有个方法集。一个非接口类型的方法集由所有为它声明的（不管是显式的还是隐式的，但不包含方法名为空标识符的）方法的原型组成。 接口类型将在下一篇文章详述。

比如，在上面的例子中，Book类型的方法集为：

Pages() int

而*Book类型的方法集为：

Pages() int
SetPages(pages int)

方法集中的方法原型的次序并不重要。

对于一个方法集，如果其中的每个方法原型都处于另一个方法集中，则我们说前者方法集为后者（即另一个）方法集的子集，后者为前者的超集。 如果两个方法集互为子集（或超集），则这两个方法集必等价。

给定一个类型T，假设它既不是一个指针类型也不是一个接口类型，因为上一节中提到的原因，类型T的方法集总是类型*T的方法集的子集。 比如，在上面的例子中，Book类型的方法集为*Book类型的方法集的子集。

请注意：不同代码包中的同名非导出方法将总被认为是不同名的。

方法集在Go中的多态特性中扮演着重要的角色。多态将在下一篇文章中讲解。

下列类型的方法集总为空：

• 内置基本类型；
• 定义的指针类型；
• 基类型为指针类型或者接口类型的指针类型；
• 非定义的数组/切片/映射/函数/通道类型。

package main

import “fmt”
type Book struct {
    pages int
}
func (b Book) Pages() int {
    return b.pages
}
func (b *Book) SetPages(pages int) {
    b.pages = pages
}
func main() {
    var book Book
fmt.Printf("%T \n", book.Pages)       // func() int
fmt.Printf("%T \n", (&book).SetPages) // func(int)
// &book值有一个隐式方法Pages。
fmt.Printf("%T \n", (&book).Pages)    // func() int

// 调用这三个方法。
(&book).SetPages(123)
book.SetPages(123)           // 等价于上一行
fmt.Println(book.Pages())    // 123
fmt.Println((&book).Pages()) // 123
}

（和C语言不同，Go中没有->操作符用来通过指针属主值来调用方法。(&book)->SetPages(123)在Go中是非法的。）

等一下，上例中的(&book).SetPages(123)一行为什么可以被简化为book.SetPages(123)呢？ 毕竟，类型Book并不拥有一个SetPages方法。 啊哈，这可以看作是Go中为了让代码看上去更简洁而特别设计的语法糖。此语法糖只对可寻址的值类型的属主有效。 编译器会自动将book.SetPages(123)改写为(&book).SetPages(123)。 但另一方面，我们应该总是认为aBookExpression.SetPages是一个合法的选择器（从语法层面讲），即使表达式aBookExpression被估值为一个不可寻址的Book值（在这种情况下，aBookExpression.SetPages是一个无效但合法的选择器）。

如上面刚提到的，当为一个类型声明了一个方法后，每个此类型的值将拥有一个和此方法同名的成员函数。 此类型的零值也不例外，不论此类型的零值是否用nil来表示。

一个例子：

package main

type StringSet map[string]struct{}
func (ss StringSet) Has(key string) bool {
    _, present := ss[key] // 永不会产生恐慌，即使ss为nil。
    return present
}

type Age int
func (age *Age) IsNil() bool {
    return age == nil
}
func (age *Age) Increase() {
    *age++ // 如果age是一个空指针，则此行将产生一个恐慌。
}

func main() {
    _ = (StringSet(nil)).Has   // 不会产生恐慌
    _ = ((*Age)(nil)).IsNil    // 不会产生恐慌
    _ = ((*Age)(nil)).Increase // 不会产生恐慌

    _ = (StringSet(nil)).Has("key") // 不会产生恐慌
    _ = ((*Age)(nil)).IsNil()       // 不会产生恐慌

    // 下面这行将产生一个恐慌，但是此恐慌不是在调用方法的时
    // 候产生的，而是在此方法体内解引用空指针的时候产生的。
    ((*Age)(nil)).Increase()
}

package main

import “fmt”
type Book struct {
    pages int
}
func (b Book) SetPages(pages int) {
    b.pages = pages
}
func main() {
    var b Book
    b.SetPages(123)
    fmt.Println(b.pages) // 0
}

另一个例子：

package main

import "fmt"

type Book struct {
    pages int
}

type Books []Book

func (books Books) Modify() {
    // 对属主参数的间接部分的修改将反映到方法之外。
    books[0].pages = 500
    // 对属主参数的直接部分的修改不会反映到方法之外。
    books = append(books, Book{789})
}

func main() {
    var books = Books{{123}, {456}}
    books.Modify()
    fmt.Println(books) // [{500} {456}]
}

有点题外话，如果将上例中Modify方法中的两行代码次序调换，那么此方法中的两处修改都不能反映到此方法之外。

func (books Books) Modify() {
    books = append(books, Book{789})
    books[0].pages = 500
}

func main() {
    var books = Books{{123}, {456}}
    books.Modify()
    fmt.Println(books) // [{123} {456}]
}

这两处修改都不能反映到Modify方法之外的原因是append函数调用将开辟一块新的内存来存储它返回的结果切片的元素。 而此结果切片的前两个元素是属主参数切片的元素的副本。对此副本所做的修改不会反映到Modify方法之外。

为了将此两处修改反映到Modify方法之外，Modify方法的属主类型应该改为指针类型：

func (books *Books) Modify() {
    *books = append(*books, Book{789})
    (*books)[0].pages = 500
}

func main() {
    var books = Books{{123}, {456}}
    books.Modify()
    fmt.Println(books) // [{500} {456} {789}]
}

• 太多的指针可能会增加垃圾回收器的负担。
• 如果一个值类型的尺寸太大，那么属主参数在传参的时候的复制成本将不可忽略。 指针类型都是小尺寸类型。 关于各种不同类型的尺寸，请阅读值复制代价一文。
• 在并发场合下，同时调用为值类型属主和指针类型属主方法比较易于产生数据竞争。
• sync标准库包中的类型的值不应该被复制，所以如果一个结构体类型内嵌了这些类型，则不应该为这个结构体类型声明值类型属主的方法。