gopl-zh.github.com/ch6/ch6-03.md

## 6.3. 通過嵌入結構體來擴展類型

來看看ColoredPoint這個類型：
```go
gopl.io/ch6/coloredpoint
import "image/color"
type Point struct{ X, Y float64 }
type ColoredPoint struct {
    Point
    Color color.RGBA
}
```

我們完全可以將ColoredPoint定義爲一個有三個字段的struct，但是我們卻將Point這個類型嵌入到ColoredPoint來提供X和Y這兩個字段。像我們在4.4節中看到的那樣，內嵌可以使我們在定義ColoredPoint時得到一種句法上的簡寫形式，並使其包含Point類型所具有的一切字段，然後再定義一些自己的。如果我們想要的話，我們可以直接認爲通過嵌入的字段就是ColoredPoint自身的字段，而完全不需要在調用時指齣Point，比如下面這樣。

```go
var cp ColoredPoint
cp.X = 1
fmt.Println(cp.Point.X) // "1"
cp.Point.Y = 2
fmt.Println(cp.Y) // "2"
```

對於Point中的方法我們也有類似的用法，我們可以把ColoredPoint類型當作接收器來調用Point裡的方法，卽使ColoredPoint裡沒有聲明這些方法：

```go
red := color.RGBA{255, 0, 0, 255}
blue := color.RGBA{0, 0, 255, 255}
var p = ColoredPoint{Point{1, 1}, red}
var q = ColoredPoint{Point{5, 4}, blue}
fmt.Println(p.Distance(q.Point)) // "5"
p.ScaleBy(2)
q.ScaleBy(2)
fmt.Println(p.Distance(q.Point)) // "10"
```
Point類的方法也被引入了ColoredPoint。用這種方式，內嵌可以使我們定義字段特別多的復雜類型，我們可以將字段先按小類型分組，然後定義小類型的方法，之後再把它們組合起來。

讀者如果對基於類來實現面向對象的語言比較熟悉的話，可能會傾向於將Point看作一個基類，而ColoredPoint看作其子類或者繼承類，或者將ColoredPoint看作"is a" Point類型。但這是錯誤的理解。請註意上面例子中對Distance方法的調用。Distance有一個參數是Point類型，但q並不是一個Point類，所以儘管q有着Point這個內嵌類型，我們也必鬚要顯式地選擇它。嘗試直接傳q的話你會看到下面這樣的錯誤：

```go
p.Distance(q) // compile error: cannot use q (ColoredPoint) as Point
```

一個ColoredPoint並不是一個Point，但他"has a"Point，並且它有從Point類裡引入的Distance和ScaleBy方法。如果你喜歡從實現的角度來考慮問題，內嵌字段會指導編譯器去生成額外的包裝方法來委託已經聲明好的方法，和下面的形式是等價的：

```go
func (p ColoredPoint) Distance(q Point) float64 {
    return p.Point.Distance(q)
}

func (p *ColoredPoint) ScaleBy(factor float64) {
    p.Point.ScaleBy(factor)
}
```

當Point.Distance被第一個包裝方法調用時，它的接收器值是p.Point，而不是p，當然了，在Point類的方法裡，你是訪問不到ColoredPoint的任何字段的。

在類型中內嵌的匿名字段也可能是一個命名類型的指鍼，這種情況下字段和方法會被間接地引入到當前的類型中(譯註：訪問需要通過該指鍼指向的對象去取)。添加這一層間接關繫讓我們可以共享通用的結構並動態地改變對象之間的關繫。下面這個ColoredPoint的聲明內嵌了一個*Point的指鍼。

```go
type ColoredPoint struct {
    *Point
    Color color.RGBA
}

p := ColoredPoint{&Point{1, 1}, red}
q := ColoredPoint{&Point{5, 4}, blue}
fmt.Println(p.Distance(*q.Point)) // "5"
q.Point = p.Point                 // p and q now share the same Point
p.ScaleBy(2)
fmt.Println(*p.Point, *q.Point) // "{2 2} {2 2}"
```

一個struct類型也可能會有多個匿名字段。我們將ColoredPoint定義爲下面這樣：
```go
type ColoredPoint struct {
    Point
    color.RGBA
}
```
然後這種類型的值便會擁有Point和RGBA類型的所有方法，以及直接定義在ColoredPoint中的方法。當編譯器解析一個選擇器到方法時，比如p.ScaleBy，它會首先去找直接定義在這個類型裡的ScaleBy方法，然後找被ColoredPoint的內嵌字段們引入的方法，然後去找Point和RGBA的內嵌字段引入的方法，然後一直遞歸向下找。如果選擇器有二義性的話編譯器會報錯，比如你在同一級裡有兩個同名的方法。

方法隻能在命名類型(像Point)或者指向類型的指鍼上定義，但是多虧了內嵌，有些時候我們給匿名struct類型來定義方法也有了手段。

下面是一個小trick。這個例子展示了簡單的cache，其使用兩個包級別的變量來實現，一個mutex互斥量(§9.2)和它所操作的cache：

```go
var (
    mu sync.Mutex // guards mapping
    mapping = make(map[string]string)
)

func Lookup(key string) string {
    mu.Lock()
    v := mapping[key]
    mu.Unlock()
    return v
}
```

下面這個版本在功能上是一緻的，但將兩個包級吧的變量放在了cache這個struct一組內：

```go
var cache = struct {
    sync.Mutex
    mapping map[string]string
}{
    mapping: make(map[string]string),
}


func Lookup(key string) string {
    cache.Lock()
    v := cache.mapping[key]
    cache.Unlock()
    return v
}
```

我們給新的變量起了一個更具表達性的名字：cache。因爲sync.Mutex字段也被嵌入到了這個struct裡，其Lock和Unlock方法也就都被引入到了這個匿名結構中了，這讓我們能夠以一個簡單明了的語法來對其進行加鎖解鎖操作。