go中方法的接收者是值或者指针有什么区别吗？

                                                                                                     
参考文章：http://studygolang.com/articles/1113
希望解决的问题如下
假设有两个方法，一个方法的接收者是指针类型，一个方法的接收者是值类型，那么：
对于值类型的变量和指针类型的变量，这两个方法有什么区别？
如果这两个方法是为了实现一个接口，那么这两个方法都可以调用吗？
如果方法是嵌入到其他结构体中的，那么上面两种情况又是怎样的？
值类型的变量和指针类型的变量
先声明一个结构体：
type T struct {     Name string}func (t T) M1() {     t.Name = "name1"}func (t *T) M2() {     t.Name = "name2"}
M1() 的接收者是值类型 T, M2() 的接收者是值类型 *T , 两个方法内都是改变Name值。
下面声明一个 T 类型的变量，并调用 M1() 和 M2() 。
    t1 := T{"t1"}      fmt.Println("M1调用前：", t1.Name)     t1.M1()     fmt.Println("M1调用后：", t1.Name)      fmt.Println("M2调用前：", t1.Name)     t1.M2()     fmt.Println("M2调用后：", t1.Name)
输出结果为：
M1调用前： t1 M1调用后： t1 M2调用前： t1 M2调用后： name2
下面猜测一下go会怎么处理。
先来约定一下：接收者可以看作是函数的第一个参数，即这样的： func M1(t T), func M2(t *T)。 go不是面向对象的语言，所以用那种看起来像面向对象的语法来理解可能有偏差。
当调用 t1.M1() 时相当于 M1(t1) ，实参和行参都是类型 T，可以接受。此时在M1()中的t只是t1的值拷贝，所以M1()的修改影响不到t1。
当调用 t1.M2() => M2(t1)，这是将 T 类型传给了 *T 类型，go可能会取 t1 的地址传进去： M2(&t1)。所以 M2() 的修改可以影响 t1 。
T 类型的变量这两个方法都是拥有的。
下面声明一个 *T 类型的变量，并调用 M1() 和 M2() 。
    t2 := &T{"t2"}      fmt.Println("M1调用前：", t2.Name)     t2.M1()     fmt.Println("M1调用后：", t2.Name)      fmt.Println("M2调用前：", t2.Name)     t2.M2()     fmt.Println("M2调用后：", t2.Name)
输出结果为：
M1调用前： t2 M1调用后： t2 M2调用前： t2 M2调用后： name2
t2.M1() => M1(t2)， t2 是指针类型， 取 t2 的值并拷贝一份传给 M1。
t2.M2() => M2(t2)，都是指针类型，不需要转换。
*T 类型的变量也是拥有这两个方法的。
传给接口会怎样？
先声明一个接口
type Intf interface {    M1()    M2() }
使用：
    var t1 T = T{"t1"}     t1.M1()     t1.M2()      var t2 Intf = t1     t2.M1()     t2.M2()
报错：
./main.go:9: cannot use t1 (type T) as type Intf in assignment:     T does not implement Intf (M2 method has pointer receiver)
var t2 Intf = t1 这一行报错。
t1 是有 M2() 方法的，但是为什么传给 t2 时传不过去呢？
t1 是值类型，赋值给 t2 时是复制值而不是指针，假设 t1 可以赋值给 t2， t2.M2() 修改 Name 的值时也是修改的拷贝的变量，无法影响到 t1，那把 t1 赋值给 t2 还有什么意义呢？所以这种赋值是不被允许的。
当把 var t2 Intf = t1 修改为 var t2 Intf = &t1 时编译通过，此时 t2 获得的是 t1 的地址， t2.M2() 的修改可以影响到 t1 了。
如果声明一个方法 func f(t Intf) , 参数的传递和上面的直接赋值是一样的情况。
嵌套类型
声明一个类型 S，将 T 嵌入进去
type S struct {    T}
使用下面的例子测试一下：
    t1 := T{"t1"}     s := S{t1}      fmt.Println("M1调用前：", s.Name)     s.M1()     fmt.Println("M1调用后：", s.Name)      fmt.Println("M2调用前：", s.Name)     s.M2()     fmt.Println("M2调用后：", s.Name)      fmt.Println(t1.Name)
输出：
M1调用前： t1 M1调用后： t1 M2调用前： t1 M2调用后： name2 t1
将 T 嵌入 S， 那么 T 拥有的方法和属性 S 也是拥有的，但是接收者却不是 S 而是 T。
所以 s.M1() 相当于 M1(t1) 而不是 M1(s)。
最后 t1 的值没有改变，因为我们嵌入的是 T 类型，所以 S{t1} 的时候是将 t1 拷贝了一份。
假如我们将 s 赋值给 Intf 接口会怎么样呢？
    var intf Intf = s     intf.M1()     intf.M2()
报错：
cannot use s (type S) as type Intf in assignment:     S does not implement Intf (M2 method has pointer receiver)
还是 M2() 的问题，因为 s 此时还是值类型。
var intf Intf = &s 这样的话编译通过了，如果在 intf.M2() 中改变了 Name 的值， s.Name 被改变了，但是t1.Name 依然没变，因为现在 t1 和 s 已经没有联系了。
下面嵌入 *T 试试：
type S struct {     *T}
使用时这样：
    t1 := T{"t1"}     s := S{&t1}      fmt.Println("M1调用前：", s.Name)     s.M1()     fmt.Println("M1调用后：", s.Name)      fmt.Println("M2调用前：", s.Name)     s.M2()     fmt.Println("M2调用后：", s.Name)      fmt.Println(t1.Name)
惟一的区别是最后 t1 的值变了，因为我们复制的是指针。
接着赋值给接口试试：
    var intf Intf = s     intf.M1()     intf.M2()     fmt.Println(s.Name)
编译没有报错。这里我们传递给 intf 的是值类型而不是指针，为什么可以通过呢？
拷贝 s 的时候里面的 T 是指针类型，所以调用 M2() 的时候传递进去的是一个指针。
var intf Intf = &s 的效果和上面一样。
本文来自：CSDN博客
感谢作者：qq_35902556
查看原文：go中方法的接收者是值或者指针有什么区别吗？

                     

查看原文：http://www.zoues.com/2016/10/27/go%e4%b8%ad%e6%96%b9%e6%b3%95%e7%9a%84%e6%8e%a5%e6%94%b6%e8%80%85%e6%98%af%e5%80%bc%e6%88%96%e8%80%85%e6%8c%87%e9%92%88%e6%9c%89%e4%bb%80%e4%b9%88%e5%8c%ba%e5%88%ab%e5%90%97%ef%bc%9f/