Go程序设计语言(二)

type NamedPoint struct {
    Point
    name string
}

func (n *NamedPoint) Abs() float64 {
   return n.Point.Abs() * 100.
}

n := &NamedPoint{Point{3, 4}, "Pythagoras"}
fmt.Println(n.Abs()) // prints 500

当然，你可以有多个不同类型的匿名字段 – 一个简单版本的多继承。但冲突解决规则让事情保持简单。

另外一个例子

一个更具吸引力的使用匿名字段的例子。

type Mutex struct { … }
func (m *Mutex) Lock() { … }

type Buffer struct {
    data [100]byte
    Mutex // 在Buffer中不需为第一个字段
}
var buf = new(Buffer)
buf.Lock() // == buf.Mutex.Lock()

注意：Lock的接收者是Mutex字段的地址。而不是外围的结构体。（对比子类或Lisp的mix-ins）

其他类型

方法不仅适用于结构体。他们可以被定义为用于任何非指针类型。

但这个类型必须在你的包中定义。你不能为int编写方法，但你可以声明一个新的int类型，并为其添加方法。

type Day int
var dayName = []string {
    "Monday", "Tuesday", "Wednesday", …
}
func (day Day) String() string {
    return dayName[day]
}

其他类型

现在我们有一个类似枚举的类型，它知道如何打印自己。

const (
    Monday Day = iota
    Tuesday
    Wednesday
    // …
)
var day = Tuesday
fmt.Printf("%q", day.String()) // 打印 "Tuesday"

Print认识string方法

技术上后续会交待，fmt.Print和相近函数可以识别出实现了String方法的值，就像前面定义的类型Day。通过调用这个方法，这些值可以被自动格式化。

于是：
   
fmt.Println(0, Monday, 1, Tuesday)

输出0 Monday 1 Tuesday。

Println可以区分出普通0和值为0的Day类型值。

因此，为你的类型定义一个String方法，这样后续无需再进行其他工作，你的类型就可以获得优雅的输出格式。

方法和字段的可见性

回顾：
  在可见性方面，Go与C++有着很大不同。

1) Go是包作用域，而C++则是文件作用域。
2) 拼写方式决定了是导出的/本地的(公有的/私有的)。
3) 同一包中的结构体有权访问另一个结构体的字段和方法。
4) 本地类型可以导出其字段和方法。
5) 没有真正意义上的子类，没有"protected"符号。

这些规则看起来在实际当中工作良好。

接口

离近点儿观察

我们接下来了解一下Go语言最不同寻常的一点：接口。

请先将你的成见留在门外。

简介

到目前为止，所有我们检视的类型都是具体的：它们实现了一些东西。

还有一个类型需要考虑：接口类型。它是完全抽象的；它不包含任何实现；它提供了一些一个实现必须实现的属性。

接口在概念上非常接近Java，Java中有一个interface类型，但Go的“接口值”概念是非常新颖的。

一个接口的定义

在Go中单词interface似乎有些使用过度了：涉及接口的有接口概念、接口类型以及接口值。

定义：
    一个接口是一组方法的集合。

由一个具体类型，如一个结构体实现的方法形成了那个类型的接口。

例子

之前我们见过这个简单的例子：

type Point struct { x, y float64 }
func (p *Point) Abs() float64 { … }

类型Point的接口拥有方法：

Abs() float64

注意其方法不是：

func (p *Point) Abs() float64

因为接口不应带有接收者的限定。

我们将Point嵌入一个新类型中：NamePoint。NamePoint将具有相同的接口。

接口类型

一个接口类型是一个接口的规格，一组由其他类型来实现的方法。这里是一个简单的例子，只包含一个方法：

type AbsInterface interface {
    Abs() float64 // 接收者是隐式的
}

这是由Point实现的接口的定义，或者用我们的术语来讲，Point实现了AbsInterface。

也可以说成，NamedPoint和Point3实现了AbsInterface方法。

方法写在接口声明内部。

一个例子

type MyFloat float64

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

MyFloat实现了AbsInterface接口，即便float64没有实现。

顺便：MyFloat不是float64的"装箱"类型；它的表示与float64相同。

多对多

一个接口可以被任意个类型所实现。ABsInterface可以被任何拥有签名如Abs() float64的类型实现，不管该类型是否有其他方法。

一个类型可以实现任意个接口。Point至少实现了下面两个：

type AbsInterface interface { Abs() float64 }
type EmptyInterface interface { }

并且，也许更多，取决于它的方法。

每个类型都实现了EmptyInterface。这将会非常有用。

接口值

一旦一个变量被声明为接口类型，它就可以被赋予任何实现了该接口的类型的值。

var ai AbsInterface
pp := new(Point)
ai = pp // OK：*Point中有Abs方法
ai = 7 // 编译错误, float64没有Abs方法
ai = MyFloat(-7.) // OK：MyFloat有Abs方法
              
ai = &Point{ 3, 4 }
fmt.Printf(ai.Abs()) // 方法调用

输出：5

注意：ai不是指针，它是个接口值。

在内存中

ai不是一个指针！它是一个多字(multiword)数据结构。

ai: receiver value | method table ptr

不同时刻，它的值和类型不同：

ai = &Point{3,4} (*Point在地址0xff1234)

0xff1234| ———–> (*Point) Abs() float64

ai = MyFloat(-7.):

-7. | ——–> (MyFloat) Abs() float64

三个重要事实

1) 接口定义了一组方法。他们是纯洁的且抽象的：没有实现，没有数据字段。Go在接口和实现之间具有清晰的区分。
2) 接口值只是值。它们包含任何实现了接口所有方法的具体值。那些具体值可以是也可以不是指针。
3) 类型通过实现方法来实现接口。它们无需声明它们要做这些事情。例如，每个类型都实现了空接口interface{}。

例子：io.Writer

下面是fmt.Fprintf的实际签名：

func Fprintf(w io.Writer, f string, a … interface{}) (n int, error os.Error)

它不是写入一个文件，而是写入类型为io.Writer的东西中。Writer定义在io包中：

type Writer interface {
    Write(p []byte) (n int, err os.Error)
}

Fprintf因此可以用于写入任何具有Write方法的类型，包括文件、管道、网络链接等。

缓冲I/O

...一个写缓冲。下面来自于bufio包：

type Writer struct { … }

bufio.Writer实现了经典的Write方法。

func (b *Writer) Write(p []byte) (n int, err os.Error)

它还拥有一个工厂方法：传入一个io.Writer，它将以bufio.Writer的形式返回一个缓冲io.Writer：

func NewWriter(wr io.Writer) (b *Writer, err os.Error)

当然，os.File也实现了Writer。

放在一起

import (
    "bufio"; "fmt"; "os"
)
func main() {
    // 无缓冲
    fmt.Fprintf(os.Stdout, "%s, ", "hello")
    // 带缓冲: os.Stdout实现了io.Writer
    buf := bufio.NewWriter(os.Stdout)
    // 现在buf也带缓冲
    fmt.Fprintf(buf, "%s\n", "world!")
    buf.Flush()
}

缓冲可以适合任何Writes的对象。

是不是感觉特像Unix管道啊？可组合性非常强大；参见crypto包。

io包中的其他公共接口

io包拥有：

Reader
Writer
ReadWriter
ReadWriteCloser

这些都是程式化的接口，不过很显然它们捕捉到了任何实现了其名字含义的函数的功能。

这就是为何我们拥有一个带缓冲的I/O包的原因，其实现与I/O自身的实现分开：它同时接受以及提供接口值。

比较

从C++角度去看，接口类型像一个纯抽象类，指定方法，但不实现。

从Java角度去看，接口类型更像是一个Java接口。

然而，在Go中，有一个最大的不同：一个类型不需要声明它要实现的接口，也不需要继承那些接口。如果它实现了相同的方法，它就实现了接口。

其他差异会变得显而易见了。

匿名字段也适用

type LockedBufferedWriter struct {
    Mutex // has Lock and Unlock methods
    bufio.Writer // has Write method
}
func (l *LockedBufferedWriter) Write(p []byte)
(nn int, err os.Error) {
    l.Lock()
    defer l.Unlock()
    return l.Writer.Write(p) // inner Write()
}

LockedBufferedWriter实现了io.Writer，但是通过匿名Mutex类型实现的。

type Locker interface { Lock(); Unlock() }

例子：HTTP服务

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

这是一个在HTTP server包中定义的接口。要提供http服务，可定义一个类型，实现这个接口，连接到服务器(细节省略了)。

type Counter struct {
    n int // or could just say type Counter int
}

func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "counter = %d\n", ctr.n)

    ctr.n++
}

现在我们定义一个类型来实现ServeHTTP：

type HandlerFunc func(http.ResponseWriter, *http.Request)
func (f HandlerFunc) ServeHTTP(w http.ResponseWriter,
req *http.Request) {

    f(w, req) // 接收者是一个函数，调用它
}

将函数转换为从属的方法，实现该接口：

var Handle404 = HandlerFunc(notFound)

容器(container)& 空接口

vector实现的梗概。(实际中，倾向于用原始slice替换，但这是有益处的)

type Element interface {}

// Vector本身就是容器.
type Vector []Element

// At()返回第i个元素.
func (p *Vector) At(i int) Element {
    return p[i]
}

Vector可以存储任何类型的元素，因为任何类型都实现了空接口。(事实上，每个元素也可以是不同类型)

类型断言

一旦你像一个Vector中存入一些数据，这个数据将被当成一个接口值存储起来。需要用“拆箱”的方法将其还原：使用“类型断言”，其语法：

interfaceValue.(typeToExtract)

当类型错误时，断言将失败- 不过看下一slide。

var v vector.Vector
v.Set(0, 1234.) // 作为接口值存储
i := v.At(0) // 作为interface{}被获取
if i != 1234. {} // 编译期错误
if i.(float64) != 1234. {} // OK
if i.(int) != 1234 {} // 运行期错误
if i.(MyFloat) != 1234. {} // err: 非MyFloat

类型断言总是在运行期执行。编译器拒绝注定要失败的断言。

接口到接口的转换

到目前为止，我们只将常规值与接口值做了相互转换，但接口值还包含相应的方法，这些方法也可以被转换。

实际上，这与将一个接口值做"拆箱"析出其中的具体值，接着为新接口类型装箱类似。

转换成功与否取决于底层的值，而不是原先的接口类型。

接口转换例子

已知：

var ai AbsInterface
type SqrInterface interface { Sqr() float64 }
var si SqrInterface
pp := new(Point) // *Point具有方法Abs, Sqr
var empty interface{}

下面这些都OK:

empty = pp // 所有类型值都满足empty
ai = empty.(AbsInterface) // 底层值实现Abs接口，否则运行时错误
                         
si = ai.(SqrInterface) // *Point实现Sqr()，即使AbsInterface没有

empty = si // *Point 实现了空集
           // 注意: 静态可检查，因此类型断言不是必要的
         

用类型断言测试

可以使用"comma ok"类型断言测试一个值是否是某种类型：

elem := vector.At(0)
if i, ok := elem.(int); ok {
    fmt.Printf("int: %d\n", i)
} else if f, ok := elem.(float64); ok {
    fmt.Printf("float64: %g\n", f)
} else {
    fmt.Print("unknown type\n")
}

用类型switch测试

特殊语法：

switch v := elem.(type) { // 字面值关键字 "type"
case int:
    fmt.Printf("is int: %d\n", v)
case float64:
    fmt.Printf("is float64: %g\n", v)
default:
    fmt.Print("unknown type\n")
}

v实现m()了吗？   

再深入一步，可以测试一个值是否实现了某个方法。

type Stringer interface { String() string }
if sv, ok := v.(Stringer); ok {
    fmt.Printf("implements String(): %s\n",
    sv.String()) // 注意: sv 不是 v
}

这个就是Print等检查某个类型是否可以打印自己的方法。

反射和…

Go提供了一个反射(reflect)包，以支持你通过值探索其类型相关信息。太错综复杂，在这里说不方便。不过我们用Printf来分析一下其参数。

func Printf(format string, args …interface{})(n int, err os.Error)

在Printf内部，args变量变成一个特定类型的slice，例如[]interface{}。并且Printf使用反射包去解包每个元素以分析其类型。

下一个小节有更多有关可变个数参数的函数的内容。

反射和Print

因此，Printf和同族函数知道参数的确切类型。正是因为它们知道参数到底是无符号的或是长整型的，才不需要%u或%ld，只需要%d。

这也是Println和Print可以在没有格式化字符串参数时也可以优雅打印参数的原因。

Printf还有一个%v("值")可以默认打印任何类型的值。

fmt.Printf("%v %v %v %v", -1, "hello",
[]int{1,2,3}, uint64(456))

输出：-1 hello [1 2 3] 456。

事实上，%v等价于由Print和Println完成格式化工作。

可变参数函数

可变参数函数：…

变长参数列表用语法…T声明，T是独立参数的类型。这样的参数必须放在参数列表的末尾。在函数中，变参隐式类型为[]T。

func Min(args …int) int {
    min := int(^uint(0)>>1) // 可能的最大整型值
    for _, x := range args { // args的类型为 []int
        if min > x { min = x }
    }
    return min
}

fmt.Println(Min(1,2,3), Min(-27), Min(), Min(7,8,2))

输出：1 -27 2147483647 2

将slice转换为可变参数

参数变成了一个slice。如果你要将slice直接传递给函数作为参数该如何做呢？ 在调用时使用…(只适用于可变参数)

回顾：
    func Min(args …int) int

下面两个调用都返回-2：

Min(1, -2, 3)
slice := []int{1, -2, 3}
Min(slice…) // … 将slice转换为参数

然而，下面的代码将会引发一个类型错误：

Min(slice)

因为slice类型为[]int，而Min的参数必须是独立的int。…是必须的。

Printf用于错误输出

我们可以使用…手法包装Printf或其某个变体来创建我们自己的错误处理函数。

func Errorf(fmt string, args …interface{}) {
    fmt.Fprintf(os.Stderr, "MyPkg: "+fmt+"\n", args…)
    os.Exit(1)
}

我们可以这样使用它：

if err := os.Chmod(file, 0644); err != nil {
    Errorf("couldn't chmod %q: %s", file, err)
}

输出(包括换行符)：

MyPkg: couldn't chmod "foo.bar": permission denied

附加(append)

用于加长slice的内置函数append是支持可变参数的。它的函数签名：
    append(s []T, x …T) []T

其中s是个Slice，T是其中元素的类型。它返回一个新slice，即附加了新增元素x的s。

slice := []int{1, 2, 3}
slice = append(slice, 4, 5, 6)
fmt.Println(slice)

打印： [1 2 3 4 5 6]

只要可能，append就会在正确的位置上增加slice。

附加一个slice

如果你想附加一个整个slice，而不是单个元素，我们再一次在调用时使用…。

slice := []int{1, 2, 3}
slice2 := []int{4, 5, 6}
slice = append(slice, slice2…) // …是必须的
fmt.Println(slice)

这里例子也打印[1 2 3 4 5 6]。