Go基礎語法（六）
方法
方法其實就是一個函式，在 func 這個關鍵字和方法名中間加入了一個特殊的接收器型別。接收器可以是結構體型別或者是非結構體型別。接收器是可以在方法的內部訪問的。
建立一個方法的語法：
func (t Type) methodName(parameter list) {
}
示例程式碼：
package main
import (
"fmt"
)
type Employee struct {
namestring
salaryint
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 {
namestring
salaryint
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)
}
既然可以使用函式實現，為什麼還要有方法？
- ofollow,noindex">Go 不是純粹的面向物件程式語言 ，而且Go不支援類。因此，基於型別的方法是一種實現和類相似行為的途徑。
- 相同的名字的方法可以定義在不同的型別上，而相同名字的函式是不被允許的。假設我們有一個 Square 和 Circle 結構體。可以在 Square 和 Circle 上分別定義一個 Area 方法。見下面的程式。
package main
import (
"fmt"
"math"
)
type Rectangle struct {
length int
widthint
}
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
ageint
}
/*
使用值接收器的方法。
*/
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 {
citystring
state string
}
func (a address) fullAddress() {
fmt.Printf("Full address: %s, %s", a.city, a.state)
}
type person struct {
firstName string
lastNamestring
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
widthint
}
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
widthint
}
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