方法

Go没有类,方法跟函数的区别就是多了一个接收器Receiver

指针接收器,接收到的变量是指针形式的,意味着可以修改原变量。pointer receivers比value receivers更加常见。

函数的参数为指针必须显式传入一个指针,但如果是方法,Go解释器会隐式地将对象的指针传入,不需要显式取地址。同样的情况也发生在参数为值value的情况下,方法依然会进行隐式转换。

1
2
3
4
5
var v Vertex
ScaleFunc(v, 5) // error
ScaleFunc(&v, 5) // ok
v.Scale(5) // OK
(&v).Scale(5) // OK

指针接收器优点: 1.可以改变原变量;2.避免了传值拷贝

接口

接口也是一种type。没有类,感觉像是在type上去实现方法。可以看成(value, type)的元组。
接口内的值就算是nil,也可以调用它的方法,不会报空指针异常。但是如果是nil接口,就会报错。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 不会报错
func (t *T) M() {}
var t *T
t.M()
// 会报错
var i I
i.M()

type I interface {
M()
}
type F float64
func (f F) M() {} // 这样就实现了接口I
var i I = F(1.2) // 可以给接口赋值
i.M() // 调用接口实现中的方法

// 空接口可以接收任意类型的值
func describe(i interface{}) {
fmt.Printf("(%v, %T)\n", i, i)
}
// 判断接口具体的类型,跟map类似
t, ok := i.(T)

Error处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 实现了error接口的ErrNegativeSqrt
type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {
return fmt.Sprintf("cannot Sqrt negative number: %v", float64(e))
}

func Sqrt(x float64) (float64, error) {
if x > 0 {
z := 1.0
for last_z := z; math.Abs(last_z-z) > 0.00001; last_z = z {
z -= (z*z - x) / (2*z)
}
return z, nil
}
return 0, ErrNegativeSqrt(x)
}

func main() {
fmt.Println(Sqrt(2))
fmt.Println(Sqrt(-2))
}

// 实现了从无限流中读取'A'的Read方法
type MyReader struct{}

func (m MyReader) Read(bytes []byte) (n int, e error) {
for i:=0; i<len(bytes); i++ {
bytes[i]='A'
}
return len(bytes), nil
}

在io.Reader上包装,实现rot13算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main

import (
"io"
"os"
"strings"
)

type rot13Reader struct {
r io.Reader
}

func transform(b byte) (bb byte) {
if (b >= 65 && b < 78) || (b >= 97 && b < 110) {
bb = b+13
} else if (b >= 78 && b < 91) || (b >= 110 && b < 123) {
bb = b-13
}
return bb
}

func (rot rot13Reader) Read(b []byte) (int, error) {
n, e := rot.r.Read(b)
for i:=0; i<n; i++ {
b[i] = transform(b[i])
}
return n, e
}

func main() {
s := strings.NewReader("Lbh penpxrq gur pbqr!")
r := rot13Reader{s}
io.Copy(os.Stdout, &r)
// output: Youcrackedthecode
}

实现Image接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package main

import (
"golang.org/x/tour/pic"
"image/color"
"image"
)
// 定义了一个Image结构体
type Image struct{
w int
h int
}
// Image实现Image的接口
/*
type Image interface {
ColorModel() color.Model
Bounds() Rectangle
At(x, y int) color.Color
}
*/
func (img Image) ColorModel() color.Model {
return color.RGBAModel
}

func (img Image) Bounds() image.Rectangle {
return image.Rect(0, 0, img.w, img.h)
}

func (img Image) At(x, y int) color.Color {
v := uint8(x^y)
return color.RGBA{v, v, 255, 255}
}

func main() {
m := Image{w:200, h:200}
// 使用实现了Image接口的m
pic.ShowImage(m)
}