Go 方法和接口

转自：http://studygolang.com/topics/549

Go 没有类，但可以在结构体类型上定义方法。

package main
import (
    "fmt"
    "math"
)

type Vertex struct { X, Y float64 }

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

func main() {
    v := &Vertex{, } fmt.Println(v.Abs())
} 

可以对包中的 任意 类型定义任意方法，而不仅仅是针对结构体。但是，不能对来自其他包的类型或基础类型定义方法。 接收者为指针的方法：方法可以与命名类型或命名类型的指针关联。有两个原因需要使用指针接收者：避免在每个方法调用中拷贝值（如果值类型是大的结构体的话会更有效率）；方法可以修改接收者指向的值。

package main

import (
    "fmt"
    "math"
)

type MyFloat float64

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

func main() {
    f := MyFloat(-math.Sqrt2)
    fmt.Println(f.Abs())
}     

接口：接口类型是由一组方法定义的集合。接口类型的值可以存放实现这些方法的任何值。

package main

import ( "fmt" "math" )

type Abser interface { Abs() float64 }

func main() {
    var a Abser f := MyFloat(-math.Sqrt2)
    v := Vertex{, }
    a = f  // a MyFloat 实现了 Abser
    a = &v // a *Vertex 实现了 Abser
    // 下面一行，v 是一个 Vertex（而不是 *Vertex）
    // 所以没有实现 Abser。
    a = v

    fmt.Println(a.Abs())
}

type MyFloat float64

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

type Vertex struct { X, Y float64 }

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

隐式接口：解藕了实现接口的包和定义接口的包：互不依赖。因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

package main

import ( "fmt" "os" )

type Reader interface { Read(b []byte) (n int, err error) }

type Writer interface { Write(b []byte) (n int, err error) }

type ReadWriter interface { Reader Writer }

func main() { 

　　var w Writer

　　// os.Stdout 实现了 Writer
　　w = os.Stdout

　　fmt.Fprintf(w, "hello, writer\n")
} 

下面列举几个go标准包的接口：

type Stringer struct { String() string }

type error interface { Error() string }

io.Reader 接口有一个 Read 方法：

func (T) Read(b []byte) (n int, err error)

Read 用数据填充指定的字节 slice，并且返回填充的字节数和错误信息。

在遇到数据流结尾时，返回 io.EOF 错误。

package main
import (
    "fmt"
    "io"
    "strings"
)

func main() {
    r := strings.NewReader("Hello, Reader!")

    b := make([]byte, )
    for {
        n, err := r.Read(b)
        fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
        fmt.Printf("b[:n] = %q\n", b[:n])
        if err == io.EOF {
            break
        }
    }
} 

Web服务器： 包 http 通过任何实现了 http.Handler 的值来响应 HTTP 请求：

type Handler interface { ServeHTTP(w ResponseWriter, r *Request) }

package main

import (
    "fmt"
    "log"
    "net/http"
)

type Hello struct{}

func (h Hello) ServeHTTP( w http.ResponseWriter, r *http.Request) {
　　fmt.Fprint(w, "Hello!")
}

func main() {
    var h Hello err := http.ListenAndServe("localhost:4000", h)
    if err != nil
    {
        log.Fatal(err)
    }
}
  

图片：

type Image interface { ColorModel() color.Model Bounds() Rectangle At(x, y int) color.Color }