golang语法学习(三) golang的面向对象机制-接口与方法

方法:

1. Go 没有类。然而，可以在结构体类型上定义方法。例如:

[plain]  view plain  copy

 print ?

1. package main  
2. import (  
3.     "fmt"  
4.     "math"  
5. )  
6.   
7. type Vertex struct {  
8.     X, Y float64  
9. }  
10.   
11. func (v *Vertex) Abs() float64 {         //这里面定义了结构提Vertex这个结构体的方法  
12.     return math.Sqrt(v.X*v.X + v.Y*v.Y)  
13. }  
14.   
15. func main() {  
16.     v := &Vertex{3, 4}  
17.     fmt.Println(v.Abs())  
18. }  

//运行结果是 5

2. 可以对包中的 任意 类型(以type定义的类)定义任意方法，而不仅仅是针对结构体。但是，不能对来自其他包的类型或基础类型定义方法。 

[plain]  view plain  copy

 print ?

1. package main  
2. import (  
3.     "fmt"  
4.     "math"  
5. )  
6.   
7. type MyFloat float64  
8.   
9. func (f MyFloat) Abs() float64 {  
10.     if f < 0 {  
11.         return float64(-f)  
12.     }  
13.     return float64(f)  
14. }  
15.   
16. func main() {  
17.     f := MyFloat(-math.Sqrt2)  
18.     fmt.Println(f.Abs())过这个接口可以用来自定义fmt.Println()  
19. }  

过这个接口可以用来自定义fmt.Println()

3. 有时候我们需要将接受方法的对象定义为指针，这样可以有两个效果：

1) 可以提高参数传递的效率，不用拷贝。

2) 修改接收者指向的值。

接口：

1. 接口类型是由一种方法定义的集合，接口定义的方式是：type Abser interface { }

例如下面的这段代码

[plain]  view plain  copy

 print ?

1. package main  
2.   
3. import (  
4.     "fmt"  
5.     "math"  
6. )  
7.   
8. type Abser interface {    //这里定义了接口 Abser，具有方法Abs(), 这个方法分别由MyFloat类以及Vertex类调用  
9.     Abs() float64  
10. }  
11.   
12. func main() {  
13.     var a Abser  
14.     f := MyFloat(-math.Sqrt2)  
15.     v := Vertex{3, 4}  
16.   
17.     a = f  // a MyFloat 实现了 Abser  
18.   
19.     fmt.Println(a.Abs())  
20.   
21.   
22.     a = &v // a *Vertex 实现了 Abse  
23.   
24.     fmt.Println(a.Abs())  
25. }  
26.   
27. type MyFloat float64  
28.   
29. func (f MyFloat) Abs() float64 {  
30.     if f < 0 {  
31.         return float64(-f)  
32.     }  
33.     return float64(f)  
34. }  
35.   
36. type Vertex struct {  
37.     X, Y float64  
38. }  
39.   
40. func (v *Vertex) Abs() float64 {  
41.     return math.Sqrt(v.X*v.X + v.Y*v.Y)  
42. }  

2. 介绍一个特殊的接口, fmt包中定义的Stringer

type Stringer interface {
    String() string
}

通过这个接口可以用来自定义fmt.Println(), 例如下面的这个例子

[plain]  view plain  copy

 print ?

1. package main  
2.   
3. import "fmt"  
4.   
5. type Person struct {  
6.     Name string  
7.     Age  int  
8. }  
9.   
10. func (p Person) String() string {  
11.     return fmt.Sprintf("%v (%v years)", p.Name, p.Age)  
12. }  
13.   
14. func main() {  
15.     a := Person{"Arthur Dent", 42}  
16.     z := Person{"Zaphod Beeblebrox", 9001}  
17.     fmt.Println(a, z)  
18. }  
19.   
20. //输出格式是:  
21.   
22. Arthur Dent (42 years) Zaphod Beeblebrox (9001 years)  

3. 与此类似的接口是 error 的一个内建的接口, 可用来自定义error 的格式

type error interface {

      Error() string

}

//例如下面：

[plain]  view plain  copy

 print ?

1. package main  
2.   
3. import (  
4.     "fmt"  
5.     "time"  
6. )  
7.   
8. type MyError struct {  
9.     When time.Time  
10.     What string  
11. }  
12.   
13. func (e *MyError) Error() string {  
14.     return fmt.Sprintf("at %v, %s",  
15.         e.When, e.What)  
16. }  
17.   
18. func run() error {  
19.     return &MyError{  
20.         time.Now(),  
21.         "it didn't work",  
22.     }  
23. }  
24.   
25. func main() {  
26.     if err := run(); err != nil {  
27.         fmt.Println(err)  
28.     }  
29. }