Go基礎文法（六）

方法

方法其實就是一個函數，在 func 這個關鍵字和方法名中間加入了一個特殊的接收器類型。接收器可以是結構體類型或者是非結構體類型。接收器是可以在方法的内部通路的。

建立一個方法的文法：

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

示例代碼：

package main

import (
    "fmt"
)

type Employee struct {
    name     string
    salary   int
    currency string
}

/*
  displaySalary() 方法将 Employee 做為接收器類型
*/
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() // 調用 Employee 類型的 displaySalary() 方法
}
           

為什麼我們已經有函數了還需要方法呢？

使用方法實作上述代碼，示例：

package main

import (
    "fmt"
)

type Employee struct {
    name     string
    salary   int
    currency string
}

/*
displaySalary()方法被轉化為一個函數，把 Employee 當做參數傳入。
*/
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)
}
           

既然可以使用函數實作，為什麼還要有方法？

• Go 不是純粹的面向對象程式設計語言 ，而且Go不支援類。是以，基于類型的方法是一種實作和類相似行為的途徑。
• 相同的名字的方法可以定義在不同的類型上，而相同名字的函數是不被允許的。假設我們有一個 Square 和 Circle 結構體。可以在 Square 和 Circle 上分别定義一個 Area 方法。見下面的程式。

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())
}
           

指針接收器與值接收器

值接收器和指針接收器之間的差別在于，在指針接收器的方法内部的改變對于調用者是可見的，然而值接收器的情況不是這樣的。

package main

import (
    "fmt"
)

type Employee struct {
    name string
    age  int
}

/*
使用值接收器的方法。
*/
func (e Employee) changeName(newName string) {
    e.name = newName
}

/*
使用指針接收器的方法。
*/
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)
}
           

由于 changeAge 方法有一個指針接收器，是以我們使用 (&e) 來調用這個方法。其實沒有這個必要，Go語言讓我們可以直接使用 e.changeAge(51)。e.changeAge(51) 會自動被Go語言解釋為 (&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() //通路 address 結構體的 fullAddress 方法
}
           

在上面程式中，我們通過使用 p.fullAddress() 來通路 address 結構體的 fullAddress() 方法。明确的調用 p.address.fullAddress() 是沒有必要的。

在方法中使用值接收器 與 在函數中使用值參數

• 當一個函數有一個值參數，它隻能接受一個值參數。
• 當一個方法有一個值接收器，它可以接受值接收器和指針接收器。

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
    */
    //area(p)

    p.area()//通過指針調用值接收器
}
           

我們試圖把這個指針傳遞到隻能接受一個值參數的函數 area，編譯器将會報錯。是以我把代碼的第 33 行注釋了。

p.area() 使用指針接收器 p 調用了隻接受一個值接收器的方法 area。這是完全有效的。原因是當 area 有一個值接收器時，為了友善Go語言把 p.area() 解釋為 (*p).area()。

在方法中使用指針接收器 與 在函數中使用指針參數

• 和值參數相類似，函數使用指針參數隻接受指針，而使用指針接收器的方法可以使用值接收器和指針接收器。

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()//使用值來調用指針接收器
}
           

在被注釋掉的第 33 行，我們嘗試通過傳入值參數 r 調用函數 perimeter。這是不被允許的，因為函數的指針參數不接受值參數。如果你把這行的代碼注釋去掉并把程式運作起來，編譯器将會抛出錯誤 main.go:33: cannot use r (type rectangle) as type *rectangle in argument to perimeter.。

在第 35 行，我們通過值接收器 r 來調用有指針接收器的方法 perimeter。這是被允許的，為了友善Go語言把代碼 r.perimeter() 解釋為 (&r).perimeter()。

在非結構體上的方法

為了在一個類型上定義一個方法，方法的接收器類型定義和方法的定義應該在同一個包中。到目前為止，我們定義的所有結構體和結構體上的方法都是在同一個 main 包中，是以它們是可以運作的。

package main

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

func main() {

}
           

在上面程式,我們嘗試把一個 add 方法添加到内置的類型 int上。這是不允許的，因為 add 方法的定義和 int 類型的定義

不在同一個包中

。該程式會抛出編譯錯誤 cannot define new methods on non-local type int。

讓該程式工作的方法是為内置類型 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)
}
           

在上面程式的第5行，我們為 int 建立了一個類型别名 myInt。在第7行，我們定義了一個以 myInt 為接收器的的方法 add。

該程式将會列印出 Sum is 15。

如果本文對你有幫助，記得關注作者點贊哦~~~，持續更新ing