在go語言中沒有類。可是，是有方法的。
給結構體定義方法，在對應的 func 和方法名之間，加上方法的接收者就可以了。
比如，我們定義了一個結構體

type Vertex struct {
    X, Y float64
}

希望 Vertex 有一個 abs() 方法，就這樣寫

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X * v.X + v.Y * v.Y)
}

注意結構體的方法接收者是指針時，調用需要在前面加上 & 符號。

(&Vertex{3, 4}).Abs()

這樣寫有點冗長，在結構的方法有多個的時候，調用也不方便。你可以初始化一個變量，然后再調用。

v := &Vertex{3, 4}
v.Abs()

完整代碼看一下

package main

import(
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X * v.X + v.Y * v.Y)
}
func main() {
    v := &Vertex{3, 4}
    fmt.Println(v.Abs())
}

這個示例輸出的結果是 5
除了結構體，還可以對自己包中的任意類型，定義任意方法。（對來自其他包的類型或基礎類型是不能定義方法的。）
比如，你可以創建一個類型

type MyFloat float64

然后給這個 MyFloat 定義方法

func (f MyFloat) Abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}

完整示例

package main

import ("fmt"
"math"
)
type MyFloat float64

func (f MyFloat) Abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}
func main() {
    f := MyFloat(-math.Sqrt2)
    fmt.Println(f.Abs())
}

運行結果

1.4142135623730951

上面兩個例子中，分別實現了兩個 Abs() 。一個指針類型，一個值類型。
使用指針是為了避免在每個方法調用時都進行值拷貝（如果類型是大型結構體的話，會更有效率。）；其次，指針方法可以修改接收者指向的值。
我們定義一個 Scale 方法，用指針做類型做接收者。會發現 Scale 之后，Vertex 的值發生了改變，并影響以后的運算結果。

package main
import(
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Scale(f float64)  {
    v.X = v.X * f
    v.Y = v.Y * f
}
func (v Vertex) Abs() float64  {
    return math.Sqrt(v.X * v.X + v.Y * v.Y)
}
func main() {
    v := Vertex{3, 4}
    fmt.Printf("Before scaling: %+v, ABS: %v\n", v, v.Abs())
    v.Scale(5)
    fmt.Printf("After scaling: %+v, ABS: %v\n", v, v.Abs())
}

運行結果是

Before scaling: {X:3 Y:4}, ABS: 5
After scaling: {X:15 Y:20}, ABS: 25

之所以 Before 和 After 的結果不同，是因為 func (v *Vertex) Scale(f float64) 對 X 和 Y 做了修改，由于使用的是指針類型，所以事實上修改了 Vertex 結構體中 X 和 Y 的值。
然后 After 的輸出 v 和 v.Abs() 就和 Before 不同了。
在一些多個點共同對一個點享有修改權的場景中，指針類型很有用。