3、函数接收者中的 type

3.1 值接收者和指针接收者

比如我们有两个结构体：

type Man struct {}
type Woman struct {}

我们分别使用指针接收者和值接收者给它们添加一个Say()方法：

// Say()方法的全名为(*Man).Say()，即只有指针类型*Man才有Say()方法
func (*Man) Say() {
    fmt.Println("man say")
}
// Say()方法的全名为(Woman).Say()，即只有值类型Woman才有Say()方法
func (Woman) Say() {
    fmt.Println("woman say")
}

这里虽然它们都是 Say() 方法，但实际上方法名是不一样的，如果你使用指针接收者，方法的全名为(*Man).Say(), 如果是值类型，则全名为 Woman.Say()。严格的来说，对于前者，只能使用 (*Man) 类型来调用 Say() 方法，后者则是只能使用 Woman 类型来调用，因为值类型 Man 并没有 Say()方法，同理指针类型 *Woman 也没有 Say() 方法。

但实际编码时，使用 Man.Say() 也能通过编译，为什么呢？因为编译器做了一层隐式转换，比如：

man := Man{} // man是个值类型
man.Say() // man say   ok, 编译器将man隐式转换成了 &Man

这是因为 go 的编译器为了我们做了一次隐式转换，即将 man.Say() 转换成了 (&man).Say()，也就是对 man 做了取地址操作。同理，如果实参是值类型而形参(方法接收者)是指针类型：

ptrWoman := &Woman{}
ptrWoman.Say() // woman say   ok, 编译器将ptrWoman隐式转换成了*Woman

编译器也会为了通过编译而尽量把指针类型 ptrWoman 向 Woman 类型上"套"，这个"套"法就是对 ptrWoman 做隐式转换，转换成 (*ptrWoman).Say()，这样就跟方法名匹配上了。

那么既然编译器这么勤劳，为什么我们还需要关心这个问题呢？原因是对于接口类型，编译器"偷懒"了，并不会主动为我们做类型转换，比如我们定义一个 CanTalk 接口，里面就有这个 Say() 方法：

// 定义一个说话接口
type CanTalk interface {
  Say()
}

这样一来，Woman 和 Man 类型应该都实现了这个接口，对吧？其实不然，因为 Man 的 Say() 方法是指针接收者，所以严格来说是指针类型 *Man 实现了这个接口，而值类型 Man 并没有。同理，因为 Woman 的 Say() 方法是值类型，所以严格来说是 Woman 实现了这个接口，而 *Woman 则没有。所以，如果你把值类型 Man 的变量赋值给接口 CanTalk 是会报错的：

man := Man{} 
var canTalk CanTalk
canTalk = man // error, Man类型没有Say()方法
// error：cannot use man (type Man) as type CanTalk in assignment: 
// Man does not implement CanTalk (Say method has pointer receiver)

而反过来，如果将 指针类型的 *man 或者 值类型/指针类型的 woman 的变量赋值给CanTalk则没有问题：

man := &Man{} 
var canTalk CanTalk
canTalk = man
canTalk.Say() // man say

在Go语言中，接口变量实际上是一个由两部分组成的数据结构：一个指向实际值的指针（或数据），和一个指向类型信息的指针。而该类型信息包括方法集合信息、包路径等内容。

在将man := Man{}赋值给canTalk变量时，由于Man类型只实现了(*Man) Say()方法，而没有实现(Man) Say()方法，因此不能被赋值给CanTalk类型的变量，因为它无法满足CanTalk接口的要求。因此，这段代码会在编译期间报错：cannot use man (type Man) as type CanTalk in assignment: Man does not implement CanTalk (missing Say method)。

尽管*Man类型已经实现了Say方法，但是根据Go语言规范，只有带指针接收器的方法才可以被使用指针类型的变量调用。在这个例子中，虽然 man 是 Man 的一个值类型实例，它并不具备Man类型的Say方法可以被指针类型 CanTalk 变量调用的能力。因此，将man直接赋值给实现了Say方法的 CanTalk 类型变量会导致编译错误。解决这个问题的方法是，将man的地址赋值给 CanTalk 类型变量，即使用取地址符"&"进行显式转换：

var canTalk CanTalk
canTalk = &man
canTalk.Say()

这样就可以正确地通过 CanTalk 类型变量调用Man类型的Say方法了。

再来看看 Woman：

woman := Woman{} 
// or 
woman := &Woman{} 
var canTalk CanTalk
canTalk = woman
canTalk.Say() // woman say

woman := Woman{} 和 woman := &Woman{} 都是创建一个 Woman 类型的变量，但它们的类型和使用方式有所不同。

woman := Woman{} 是直接创建了一个 Woman 类型的值，并将其赋给 woman 变量。这时 woman 变量的类型就是 Woman，而不是指向 Woman 类型的指针。因此，对 woman 变量进行方法调用时，需要使用值类型，即：woman.Say()。同时，如果将 woman 赋值给实现了该类型的接口变量（如 var canTalk CanTalk = woman），Go 会在编译阶段自动为 woman 值生成一个指向该值的指针并赋给接口变量。

这里需要注意的是，由于值类型无法通过地址访问到，因此只有实现了 func (t T) MethodName() {...} 方法声明的值类型才可以被赋值给对应接口类型的变量。例如：func (Woman) Say() {...}。

woman := &Woman{} 则是创建了一个指向 Woman 类型的指针，并将该指针赋给 woman 变量。这时 woman 变量的类型就是 *Woman，而不是 Woman。因此，对 woman 变量进行方法调用时，需要使用指针类型，即：woman.Say() 或者 (*woman).Say()。同时，将 woman 赋值给实现了该类型的接口变量时（如 var canTalk CanTalk = woman），Go 会直接将 woman 指针赋给接口变量，无需做任何转换。

因此，使用 woman := &Woman{} 创建指向 Woman 类型的指针更为常见，可以方便地对对象进行修改和传递。如果需要直接操作值本身的数据，可以使用值类型。

需要注意的是：编译器确实会进行隐式转换，但这并不意味着你应该依赖于它。在一些情况下，隐式转换可能会导致编译错误或者程序行为不正确的问题。因此，尽量避免过度依赖编译器进行隐式转换，而是应该显式地转换数据类型以确保代码的正确性和可读性。

这里就得出一个经验，一旦你的函数的接收者的类型是指针类型并且实现一个接口的时候，在将一个实例赋值给接口类型的变量的时候，一定要是指针类型，否则编译器会报错。而如果你的函数接受者是值类型并且实现一个接口的时候，实例不管是值类型还是指针类型都会被编译器隐式生成一个指针指向接口变量，就不会报错了。