Go 方法

一般的函数定义叫做函数，定义在结构体上面的函数叫做该结构体的方法。

示例1：

  1. package main
  3. import "fmt"
  5. type rect struct {
  6.     width, height int
  7. }
  9. // 这个area方法有一个限定类型*rect，
  10. // 表示这个函数是定义在rect结构体上的方法
  11. func (r *rect) area() int {
  12.     return r.width * r.height
  13. }
  15. // 方法的定义限定类型可以为结构体类型
  16. // 也可以是结构体指针类型
  17. // 区别在于如果限定类型是结构体指针类型
  18. // 那么在该方法内部可以修改结构体成员信息
  19. func (r rect) perim() int {
  20.     return 2*r.width + 2*r.height
  21. }
  23. func main() {
  24.     r := rect{width: 10, height: 5}
  26.     // 调用方法
  27.     fmt.Println("area: ", r.area())
  28.     fmt.Println("perim:", r.perim())
  30.     // Go语言会自动识别方法调用的参数是结构体变量还是
  31.     // 结构体指针，如果你要修改结构体内部成员值，那么使用
  32.     // 结构体指针作为函数限定类型，也就是说参数若是结构体
  33.     //变量，仅仅会发生值拷贝。
  34.     rp := &r
  35.     fmt.Println("area: ", rp.area())
  36.     fmt.Println("perim:", rp.perim())
  37. }

输出结果为

  1. area:  50
  2. perim: 30
  3. area:  50
  4. perim: 30

示例2：

从某种意义上说，方法是函数的“语法糖”。当函数与某个特定的类型绑定，那么它就是一个方法。也证因为如此，我们可以将方法“还原”成函数。

instance.method(args)->(type).func(instance,args)

为了区别这两种方式，官方文档中将左边的称为Method Value，右边则是Method Expression。Method Value是包装后的状态对象，总是与特定的对象实例关联在一起（类似闭包，拐带私奔），而Method Expression函数将Receiver作为第一个显式参数，调用时需额外传递。

注意：对于Method Expression，T仅拥有T Receiver方法，T拥有（T+T）所有方法。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func main() {
  8.     p := Person{2, "张三"}
  10.     p.test(1)
  11.     var f1 func(int) = p.test
  12.     f1(2)
  13.     Person.test(p, 3)
  14.     var f2 func(Person, int) = Person.test
  15.     f2(p, 4)
  17. }
  19. type Person struct {
  20.     Id   int
  21.     Name string
  22. }
  24. func (this Person) test(x int) {
  25.     fmt.Println("Id:", this.Id, "Name", this.Name)
  26.     fmt.Println("x=", x)
  27. }

输出结果：

  1. Id: 2 Name 张三
  2. x= 1
  3. Id: 2 Name 张三
  4. x= 2
  5. Id: 2 Name 张三
  6. x= 3
  7. Id: 2 Name 张三
  8. x= 4

示例3：

使用匿名字段，实现模拟继承。即可直接访问匿名字段（匿名类型或匿名指针类型）的方法这种行为类似“继承”。访问匿名字段方法时，有隐藏规则，这样我们可以实现override效果。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func main() {
  8.     p := Student{Person{2, "张三"}, 25}
  9.     p.test()
  11. }
  13. type Person struct {
  14.     Id   int
  15.     Name string
  16. }
  18. type Student struct {
  19.     Person
  20.     Score int
  21. }
  23. func (this Person) test() {
  24.     fmt.Println("person test")
  25. }
  27. func (this Student) test() {
  28.     fmt.Println("student test")
  29. }

输出结果为：

  1. student test