Golang极简入门教程（二）：方法和接口

方法

在 golang 中没有类，不过我们可以为结构体定义方法。我们看一个例子：

package main
 
import (
    "fmt"
    "math"
)
 
type vertex struct {
    x, y float64
}
 
// 结构体 vertex 的方法
// 这里的方法接收者（method receiver）v 的类型为 *vertex
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())
}

在这里方法的接收者使用指针类型而非值类型主要出于以下几点考虑（类似 c/c++ 等语言）：

1.避免方法每次调用时，对接收者的不必要的拷贝
2.在方法内可以修改接收者的值

我们可以为任意类型定义方法，但以下情况除外：

1.如果类型定义在其他包中，不能为其定义方法
2.如果类型是基础类型，不能为其定义方法

package main
 
import (
    "fmt"
    "math"
)
 
// 定义一个类型 myfloat
type myfloat float64
 
// 注意此方法关联的类型是 myfloat 而不是 *myfloat
func (f myfloat) abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}
 
func main() {
    f := myfloat(-math.sqrt2)
    fmt.println(f.abs())
}

接口（interface）

接口也是一种类型（就像结构体一样）。一个接口类型包含了一组方法，一个接口类型能够持有那些实现了这些方法的值。范例：

// 定义接口 abser
type abser interface {
    abs() float64
}
 
// 定义结构体 vertex
type vertex struct {
    x, y float64
}
 
// 实现方法 abs
func (v *vertex) abs() float64 {
    return math.sqrt(v.x*v.x + v.y*v.y)
}
 
func main() {
    v := vertex{3, 4}
    // 成功，能够持有 *vertex 类型的值
    var a abser = &v
    // 出错，不能持有 vertex 类型的值
    // 因为在 *vertex 上定义了方法 abs，而未在 vertex 上定义
    var b abser = v
}

错误

golang 提供了一个 error 接口：

type error interface {
    error() string
}

我们通过 os.open 函数来了解一下 error 的用法：

// 此函数用于打开一个文件
// 返回的第二个值为 error 类型
func open(name string) (file *file, err error)

简单的例子：

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    _, err := os.open("test.txt")
    // 如果 err 不为 nil 表示存在错误
    if err != nil {
        fmt.println(err)
    }
}

创建一个 error 值的最简单方式是使用 errors.new 函数：

func sqrt(f float64) (float64, error) {
    if f < 0 {
        // 出错时返回一个错误
        return 0, errors.new("math: square root of negative number")
    }
    // ...
}

我们也可以定义一个新的 error 的实现（也就是实现接口 error）：

type negativesqrterror float64
 
func (f negativesqrterror) error() string {
    return fmt.sprintf("math: square root of negative number %g", float64(f))
}

匿名域

结构体中可以存在只有类型而没有名字的域，它们被叫做匿名域。例如：

struct {
    t1
    *t2
}

一个结构体的匿名域中的域或者方法可以被此结构体实例直接访问：

package main
 
import "fmt"
 
type car struct {
    wheelcount int
}
 
func (car *car) numberofwheels() int {
    return car.wheelcount
}
 
type ferrari struct {
    car
}
 
func main() {
    f := ferrari{car{4}}
    fmt.println("a ferrari has this many wheels: ", f.numberofwheels())
}