Golang中匿名组合实现伪继承

“Go语言的面向对象机制与一般语言不同。 它没有类层次结构， 甚至可以说没有类； 仅仅通过组合（ 而不是继承） 简单的对象来构建复杂的对象。” – 《Go语言圣经》

目录

1. 结构体嵌入和匿名成员

Go语言提供别样的 结构体嵌入 机制，让一个结构体包含另一个结构体类型的 匿名成员 ， 这样就可以通过简单的点运算符x.f来访问匿名成员链中嵌套的x.d.e.f成员。

Go语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字； 这类成员就叫匿名成员。 匿名成员的数据类型必须是命名的（而不是匿名的）类型或指向一个命名的类型的指针。

type Circle struct {
    Point
    Radius int
} 

type Wheel struct {
    Circle
    Spokes int
}

由于有了匿名嵌入的特性， 我们可以直接访问内嵌类型的成员变量而不需要给出完整的路径：

var w Wheel
w.X = 8 // 等价于 w.Circle.Point.X = 8
w.Y = 8 // 等价于 w.Circle.Point.Y = 8
w.Radius = 5 // 等价于 w.Circle.Radius = 5
w.Spokes = 20

同样的规则，内嵌类型的方法也会提升为外部类型的方法。

2. 匿名组合不是继承

2.1 方法的接受者没变

当我们嵌入一个类型，这个类型的方法就变成了外部类型的方法，但是当它被调用时，方法的接受者是内部类型(嵌入类型)，而非外部类型。— Effective Go

type Job struct {
    Command string
    *log.Logger
}

func (job *Job)Start() {
    job.Log("starting now...")
    ... // 做一些事情
    job.Log("started.")
}

上面这个Job例子，即使组合后调用的方式变成了job.Log(…)，但Log函数的接收者仍然是 log.Logger 指针，因此在Log中也不可能访问到job的其他成员方法和变量。

2.2 内嵌类型不是基类

如果读者对基于 类 来实现的面向对象语言比较熟悉的话， 可能会倾向于将 内嵌类型 看作一个基类， 而 外部类型 看作其子类或者继承类， 或者将 外部类型 看作 "is a" 内嵌类型 。 但这样理解是错误的。

type Point struct{ X, Y float64 }

type ColoredPoint struct {
    Point
    Color color.RGBA
}

func (p Point) Distance(q Point) float64 {
    dX := q.X - p.X
    dY := q.Y - p.Y
    return math.Sqrt(dX*dX + dY*dY)
}

请注意上面例子中对Distance方法的调用。 Distance有一个参数是Point类型， 但q并不是一个Point类， 所以尽管q有着Point这个内嵌类型， 我们也必须要显式地选择它。 尝试直接传q的话你会看到错误：

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.Distance(q) // compile error: cannot use q (ColoredPoint) as Point

一个ColoredPoint并不是一个Point， 但ColoredPoint "has a" Point， 并且它有从Point类里引入的 Distance方法。

实际上，从实现的角度来考虑问题， 内嵌字段会指导编译器去生成额外的包装方法来委托已经声明好的方法， 和下面的形式是等价的：

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

当Point.Distance被以上编译器生成的包装方法调用时， 它的接收器值是p.Point， 而不是p。

2.3 匿名冲突(duplicate field) 和隐式名字

匿名成员也有一个隐式的名字，以其类型名称（去掉包名部分）作为成员变量的名字。 因此不能同一级同时包含两个类型相同的匿名成员， 这会导致名字冲突。

type Logger struct {
    Level int
}

type MyJob struct {
    *Logger
    Name string
    *log.Logger // duplicate field Logger
}

以下两点都间接说明匿名组合不是继承：

• 匿名成员有隐式的名字
• 匿名可能冲突(duplicate field)

---

参考文章：

• Effective Go #Embedding: https://golang.org/doc/effective_go.html#embedding
• Golang继承指针与非指针的一个疑问: https://segmentfault.com/q/1010000002687684/a-1020000002688273
• [golang note] 匿名组合: https://www.cnblogs.com/heartchord/p/5254564.html