1. 方法定义

Golang 方法总是绑定对象实例，并隐式将实例作为第一实参 (receiver)。

  1. • 只能为当前包内命名类型定义方法。
  2. • 参数 receiver 可任意命名。如方法中未曾使用 ，可省略参数名。
  3. • 参数 receiver 类型可以是 T 或 *T。基类型 T 不能是接口或指针。 
  4. • 不支持方法重载，receiver 只是参数签名的组成部分。
  5. • 可用实例 value 或 pointer 调用全部方法，编译器自动转换。

一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。

所有给定类型的方法属于该类型的方法集。

1.1.1. 方法定义：

  1.     func (recevier type) methodName(参数列表)(返回值列表){}
  3.     参数和返回值可以省略
  1. package main
  3. type Test struct{}
  5. // 无参数、无返回值
  6. func (t Test) method0() {
  8. }
  10. // 单参数、无返回值
  11. func (t Test) method1(i int) {
  13. }
  15. // 多参数、无返回值
  16. func (t Test) method2(x, y int) {
  18. }
  20. // 无参数、单返回值
  21. func (t Test) method3() (i int) {
  22.     return
  23. }
  25. // 多参数、多返回值
  26. func (t Test) method4(x, y int) (z int, err error) {
  27.     return
  28. }
  30. // 无参数、无返回值
  31. func (t *Test) method5() {
  33. }
  35. // 单参数、无返回值
  36. func (t *Test) method6(i int) {
  38. }
  40. // 多参数、无返回值
  41. func (t *Test) method7(x, y int) {
  43. }
  45. // 无参数、单返回值
  46. func (t *Test) method8() (i int) {
  47.     return
  48. }
  50. // 多参数、多返回值
  51. func (t *Test) method9(x, y int) (z int, err error) {
  52.     return
  53. }
  55. func main() {}

下面定义一个结构体类型和该类型的一个方法：

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. //结构体
  8. type User struct {
  9.     Name  string
  10.     Email string
  11. }
  13. //方法
  14. func (u User) Notify() {
  15.     fmt.Printf("%v : %v \n", u.Name, u.Email)
  16. }
  17. func main() {
  18.     // 值类型调用方法
  19.     u1 := User{"golang", "golang@golang.com"}
  20.     u1.Notify()
  21.     // 指针类型调用方法
  22.     u2 := User{"go", "go@go.com"}
  23.     u3 := &u2
  24.     u3.Notify()
  25. }

输出结果：

  1.     golang : golang@golang.com 
  2.     go : go@go.com

解释： 首先我们定义了一个叫做 User 的结构体类型，然后定义了一个该类型的方法叫做 Notify，该方法的接受者是一个 User 类型的值。要调用 Notify 方法我们需要一个 User 类型的值或者指针。

在这个例子中当我们使用指针时，Go 调整和解引用指针使得调用可以被执行。注意，当接受者不是一个指针时，该方法操作对应接受者的值的副本(意思就是即使你使用了指针调用函数，但是函数的接受者是值类型，所以函数内部操作还是对副本的操作，而不是指针操作。

我们修改 Notify 方法，让它的接受者使用指针类型：

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. //结构体
  8. type User struct {
  9.     Name  string
  10.     Email string
  11. }
  13. //方法
  14. func (u *User) Notify() {
  15.     fmt.Printf("%v : %v \n", u.Name, u.Email)
  16. }
  17. func main() {
  18.     // 值类型调用方法
  19.     u1 := User{"golang", "golang@golang.com"}
  20.     u1.Notify()
  21.     // 指针类型调用方法
  22.     u2 := User{"go", "go@go.com"}
  23.     u3 := &u2
  24.     u3.Notify()
  25. }

输出结果：

  1.     golang : golang@golang.com 
  2.     go : go@go.com

注意：当接受者是指针时，即使用值类型调用那么函数内部也是对指针的操作。

方法不过是一种特殊的函数，只需将其还原，就知道 receiver T 和 *T 的差别。

  1. package main
  3. import "fmt"
  5. type Data struct {
  6.     x int
  7. }
  9. func (self Data) ValueTest() { // func ValueTest(self Data);
  10.     fmt.Printf("Value: %p\n", &self)
  11. }
  13. func (self *Data) PointerTest() { // func PointerTest(self *Data);
  14.     fmt.Printf("Pointer: %p\n", self)
  15. }
  17. func main() {
  18.     d := Data{}
  19.     p := &d
  20.     fmt.Printf("Data: %p\n", p)
  22.     d.ValueTest()   // ValueTest(d)
  23.     d.PointerTest() // PointerTest(&d)
  25.     p.ValueTest()   // ValueTest(*p)
  26.     p.PointerTest() // PointerTest(p)
  27. }

输出:

  1.     Data: 0xc42007c008
  2.     Value: 0xc42007c018
  3.     Pointer: 0xc42007c008
  4.     Value: 0xc42007c020
  5.     Pointer: 0xc42007c008

1.1.2. 普通函数与方法的区别

1.对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然。

2.对于方法（如struct的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以。

  1. package main
  3. //普通函数与方法的区别（在接收者分别为值类型和指针类型的时候）
  5. import (
  6.     "fmt"
  7. )
  9. //1.普通函数
  10. //接收值类型参数的函数
  11. func valueIntTest(a int) int {
  12.     return a + 10
  13. }
  15. //接收指针类型参数的函数
  16. func pointerIntTest(a *int) int {
  17.     return *a + 10
  18. }
  20. func structTestValue() {
  21.     a := 2
  22.     fmt.Println("valueIntTest:", valueIntTest(a))
  23.     //函数的参数为值类型，则不能直接将指针作为参数传递
  24.     //fmt.Println("valueIntTest:", valueIntTest(&a))
  25.     //compile error: cannot use &a (type *int) as type int in function argument
  27.     b := 5
  28.     fmt.Println("pointerIntTest:", pointerIntTest(&b))
  29.     //同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递
  30.     //fmt.Println("pointerIntTest:", pointerIntTest(&b))
  31.     //compile error:cannot use b (type int) as type *int in function argument
  32. }
  34. //2.方法
  35. type PersonD struct {
  36.     id   int
  37.     name string
  38. }
  40. //接收者为值类型
  41. func (p PersonD) valueShowName() {
  42.     fmt.Println(p.name)
  43. }
  45. //接收者为指针类型
  46. func (p *PersonD) pointShowName() {
  47.     fmt.Println(p.name)
  48. }
  50. func structTestFunc() {
  51.     //值类型调用方法
  52.     personValue := PersonD{101, "hello world"}
  53.     personValue.valueShowName()
  54.     personValue.pointShowName()
  56.     //指针类型调用方法
  57.     personPointer := &PersonD{102, "hello golang"}
  58.     personPointer.valueShowName()
  59.     personPointer.pointShowName()
  61.     //与普通函数不同，接收者为指针类型和值类型的方法，指针类型和值类型的变量均可相互调用
  62. }
  64. func main() {
  65.     structTestValue()
  66.     structTestFunc()
  67. }

输出结果：

  1.     valueIntTest: 12
  2.     pointerIntTest: 15
  3.     hello world
  4.     hello world
  5.     hello golang
  6.     hello golang