Golang：方法

什么是方法

一个方法只是一个函数，它有一个特殊的接收者（receiver）类型，该接收者放在 func 关键字和函数名之间。接收者可以是结构体类型或非结构体类型。可以在方法内部访问接收者。

可以通过下面的语法创建一个方法：

func (t Type) methodName(parameter list) {  
}

上面创建了一个名为 methodName 的方法，该方法有一个类型为 Type 的接收者。

简单示例

package main

import (
    "fmt"
)

type Employee struct {
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method has Employee as the receiver type
*/
func (e Employee) displaySalary() {
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    emp1.displaySalary() //Calling displaySalary() method of Employee type
}

上面创建了一个结构体类型的方法并调用它。

为什么使用方法而不是函数

package main

import (
    "fmt"
)

type Employee struct {
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method converted to function with Employee as parameter
*/
func displaySalary(e Employee) {
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    displaySalary(emp1)
}

在上面的程序中，我们使用 displaySalary 函数替换了方法，并将 Employee 结构体作为参数传给它。

为什么可以用函数完成同样的工作，却还要使用方法呢？

• Golang 不是一个纯粹的面向对象的编程语言，它不支持类。因此通过在一个类型上建立方法来实现与 class 相似的行为。

• 同名方法可以定义在不同的类型上，但是 Golang 不允许同名函数。假设有两个结构体 Square 和 Circle。在 Square 和 Circle 上定义同名的方法是合法的。

package main

import (
    "fmt"
    "math"
)

type Rectangle struct {
    length int
    width  int
}

type Circle struct {
    radius float64
}

func (r Rectangle) Area() int {
    return r.length * r.width
}

func (c Circle) Area() float64 {
    return math.Pi * c.radius * c.radius
}

func main() {
    r := Rectangle{
        length: 10,
        width:  5,
    }
    fmt.Printf("Area of rectangle %d\n", r.Area())
    c := Circle{
        radius: 12,
    }
    fmt.Printf("Area of circle %f", c.Area())
}

指针接收者 vs 值接收者

目前为止看到的都是以值作为接收者。以指针为接收者也是可以的。两者区别在于，以指针作为接收者时，方法内部进行的修改对于调用者是可见的，但是以值作为接收者却不是。

package main

import (
    "fmt"
)

type Employee struct {
    name string
    age  int
}

/*
Method with value receiver
*/
func (e Employee) changeName(newName string) {
    e.name = newName
}

/*
Method with pointer receiver
*/
func (e *Employee) changeAge(newAge int) {
    e.age = newAge
}

func main() {
    e := Employee{
        name: "Mark Andrew",
        age:  50,
    }
    fmt.Printf("Employee name before change: %s", e.name)
    e.changeName("Michael Andrew")
    fmt.Printf("\nEmployee name after change: %s", e.name)

    fmt.Printf("\n\nEmployee age before change: %d", e.age)
    (&e).changeAge(51)
    fmt.Printf("\nEmployee age after change: %d", e.age)
}

上面的程序中， changeName 方法有一个值接收者 (e Employee)，而 changeAge 方法有一个指针接收者 (e *Employee)。在 changeName 中改变 Employee 的 name 的值对调用者而言是不可见的，因此程序在调用 e.changeName("Michael Andrew") 方法之前和之后，打印的 name 是一样的。而 changeAge 的接受者是一个指针 (e *Employee)，因此通过调用方法 (&e).changeAge(51) 来修改 age 对于调用者是可见的。

使用 (&e).changeAge(51) 来调用 changeAge 方法不是必须的，Golang 允许我们省略 & 符号，因此可以写为 e.changeAge(51)。Golang 将 e.changeAge(51) 解析为 (&e).changeAge(51)。

匿名字段方法

package main

import (
    "fmt"
)

type address struct {
    city  string
    state string
}

func (a address) fullAddress() {
    fmt.Printf("Full address: %s, %s", a.city, a.state)
}

type person struct {
    firstName string
    lastName  string
    address
}

func main() {
    p := person{
        firstName: "Elon",
        lastName:  "Musk",
        address: address{
            city:  "Los Angeles",
            state: "California",
        },
    }

    p.fullAddress() //accessing fullAddress method of address struct

}

通过 p.fullAddress() 调用了 address 的方法 fullAddress()。像 p.address.fullAddress() 这样的直接调用是不必要的。

方法的值接收者 vs 函数的值参数

• 当一个函数有一个值参数时，它只接受一个值参数。

• 当一个方法有一个值接收者时，它可以接受值和指针接收者。

package main

import (
    "fmt"
)

type rectangle struct {
    length int
    width  int
}

func area(r rectangle) {
    fmt.Printf("Area Function result: %d\n", (r.length * r.width))
}

func (r rectangle) area() {
    fmt.Printf("Area Method result: %d\n", (r.length * r.width))
}

func main() {
    r := rectangle{
        length: 10,
        width:  5,
    }
    area(r)
    r.area()

    p := &r
    /*
       compilation error, cannot use p (type *rectangle) as type rectangle
       in argument to area
    */
    //area(p)

    p.area() //calling value receiver with a pointer
}

函数 func area(r rectangle) 接受一个值参数，而方法 func (r rectangle) area() 接受一个值接收者。

通过传递一个值来调用 area 函数 area(r)，它将工作。同样地，通过值接收者调用 area 方法 r.area()， 它也可以工作。

我们创建了一个指向 r 的指针 p。如果我们试图将这个指针传递给只接受值的 area 函数那么编译器将报错。

p.area() 使用指针接收者 p 调用一个值接收者方法 area 。这是完全合法的。原因是对于 p.area()，由于 area 方法必须接受一个值接收者，所以 Golang 将其解析为 (*p).area()。

方法的指针接收者 vs 函数的指针参数

具有指针参数的函数将仅接受指针，而具有指针接收者的方法将接受值和指针接收者。

package main

import (
    "fmt"
)

type rectangle struct {
    length int
    width  int
}

func perimeter(r *rectangle) {
    fmt.Println("perimeter function output:", 2*(r.length+r.width))

}

func (r *rectangle) perimeter() {
    fmt.Println("perimeter method output:", 2*(r.length+r.width))
}

func main() {
    r := rectangle{
        length: 10,
        width:  5,
    }
    p := &r //pointer to r
    perimeter(p)
    p.perimeter()

    /*
       cannot use r (type rectangle) as type *rectangle in argument to perimeter
    */
    //perimeter(r)

    r.perimeter() //calling pointer receiver with a value

}

函数 func perimeter(r *rectangle) 接受一个指针参数，而方法 func (r *rectangle) perimeter() 接受一个指针接收者。

我们通过指针参数调用 perimeter 函数，通过指针接收者调用 perimeter 方法，一切都很好。

试图以一个值参数 r 调用 perimeter 函数，这是非法的。因为一个接受指针为参数的函数不能接受一个值作为参数。如果去掉注释，则编译报错。

通过一个值接收者 r 调用一个指针接收者 perimeter 方法，这是合法的。r.perimeter() 将被 Golang 解析为 (&r).perimeter()。

非结构体类型的方法

现在我们定义的都是结构体类型的方法，同样可以定义非结构体类型的方法，不过需要注意一点。为了定义某个类型的方法，接收者类型的定义与方法的定义必须在同一个包中。

package main

func (a int) add(b int) {
}

func main() {

}

在上面的程序中，试图添加一个方法 add 给内置类型 int。这是不允许的，因为定义方法 add 所在的包和定义类型 int 的包不是同一个包。这个程序将会报编译错误：cannot define new methods on non-local type int。

使其工作的方法是为内置类型创建一个别名，然后以这个别名作为接收者创建方法。

package main

import "fmt"

type myInt int

func (a myInt) add(b myInt) myInt {  
    return a + b
}

func main() {  
    num1 := myInt(5)
    num2 := myInt(10)
    sum := num1.add(num2)
    fmt.Println("Sum is", sum)
}