什么是Golang的正交組合-垂直組合思維：Tony Bai的博客 - Coding in GO way - Orthogonal Composition

Go語言通過type embedding實現垂直組合。組合方式莫過于以下這么幾種：
a):construct interface by embedding interface
b):construct struct by embedding interface
c):construct struct by embedding struct
Go語言中沒有繼承，但是可以用結構體嵌入實現繼承，還有接口這個東西。現在問題來了：什么場景下應該用繼承，什么場景下應該用接口。這里從一個實際的案例出發。

問題描述：

網游服務器中的一個例子。假設每個實體都有一個ObjectID，每一個實例都有一個獨一無二的ObjectID。用面向對象的觀點，就是有一個Object對象，里面有getID()方法，所有對象都是繼承自Object對象。
Creature繼承Object，表示游戲中的生物。然后像Monster，Human，都繼承自Creature的。Item也繼承自Object，表示物品類。除了像裝備這種很直觀的物品，尸體這類Corpse也是繼承自Item的。而尸體又有分MonsterCorpse和HumanCorpse等。
Effect也繼承自Object，表示效果類。比如玩家身上的狀態。還有其它很多很多，全是以Object為基類的。
總之，Object是一個最下面的基類，直接的派生類很多，派生類的派生類更多，這樣一顆繼承樹結構。

實現方法：

construct struct by embedding struct

這是最簡單的繼承的方式：

//construct struct by embedding struct
type Object struct{
    ID uint
}
type Creature sturct {
    Object // Creature繼承自Object
}
type Monster struct {
    Creature // Monster繼承自Monster
}

這樣做的好處就是，Monster直接可以調用到Creature里的方法，Creature直接可以調用Object里的方法。不用重寫代碼。
但是，Go中沒有基類指針指向派生類對象，不可以Object指向一個Monster對象，調用Monster中的方法。
而我們實際上在很多地方需要這種抽象類型機制，比如存儲需要存Creature類型，使用的時候再具體用Monster類型方法。
struct中嵌入struct，被嵌入的struct的method會被提升到外面的類型中。比如stl中的poolLocal struct，對于外部來說它擁有了Lock和Unlock方法，但是實際調用時，method調用實際被傳給poolLocal中的Mutex實例。

// sync/pool.go
  type poolLocal struct {
      private interface{}   // Can be used only by the respective P.
      shared  []interface{} // Can be used by any P.
      Mutex                 // Protects shared.
      pad     [128]byte     // Prevents false sharing.
  }

construct interface by embedding interface

我們新建一個工程并定義Object接口：

//object/object.go
package object
type Object interface {
    GetID() uint  
    //每一個Object的實現類型都有一個ID值，通過GetID()獲取其ID
}

Creature也定義為一個接口，他繼承于Object，且擁有自己的方法Create()。為了體現繼承的關系，我把它放在了子目錄下：

//object/creature/creature.go
package creature
import (
    "fmt"
    "github.com/ovenvan/multi-inheritance/object"
)

type Creature interface {
    object.Object
    Create()
}

同樣Human和Monster都繼承于Creature，且擁有各自獨一無二的方法Human.Born()[略]和Monster.Hatch()：

//object/creature/monster/monster.go
package monster
import (
    "fmt"
    "github.com/ovenvan/multi-inheritance/object"
    "github.com/ovenvan/multi-inheritance/object/creature"
)
type Monster interface {
    creature.Creature
    Hatch()
}
type Mstr struct{/*some properties*/}

為了使Mstr能夠實現接口Monster，我們需要為他實現func：

func (this *Mstr) GetID() uint{/*your code*/}  
func (this *Mstr) Create() {/*your code*/}
func (this *Mstr) Hatch(){/*your code*/}
func NewMonster () Monster{return &Monster_s{}}

這樣就不會出現construct struct by embedding struct時出現的基類指針無法指向子類的問題。現在一個東西實現Object，如果它是Monster，那么一定是Creature。但屬于父類的GetID和Create方法是沒法復用的，也就是說對于Hum struct，我們仍需要重寫GetID和Create方法。如果這些方法實現基本相同，那么將會出現大量冗余代碼。

construct struct by embedding interface

為了復用父類的方法，我們必須把方法定義在父類中。于是我們就想到了在父類中創建struct供子類繼承，在父類的struct中實現方法func：

//object/object.go
package object
type Object interface {
    GetID() uint
}
type Obj struct {   //needs to be public
    id uint
}
func (this *Obj) GetID() uint{
    return this.id
}

為Creature接口創建的struct Crea 通過construct struct by embedding struct繼承Obj，如此便繼承了GetID的方法：

//object/creature/creature.go
package creature
import (
    "fmt"
    "github.com/ovenvan/multi-inheritance/object"
)
type Creature interface {
    object.Object
    Create()
}
type Crea struct {
    object.Obj      //struct 中綁定interface和struct的區別？
                    // Object只實現了一個Obj實例，這個實例的作用是被繼承，提供父類的代碼，因此應該繼承Obj，而非Object
}
func (t *Crea) Create(){
    fmt.Println("This is a Base Create Method")
}
func (t *Crea)GetID() uint{  //override
    fmt.Println("Override GetID from Creature")
    return t.Obj.GetID()
    //t.GetID()  it is a recursive call
}

為什么是construct struct by embedding struct而不是construct struct by embedding interface?如果可以實現綁定接口而非實例的話，我們是否可以不對外公開struct Obj呢。
作者至現在思考的結果是，綁定接口是可行的。不對外公開struct Obj（換言之，讓使用者無法自如的創建struct Obj）的前提是庫中使用Obj的代碼都與Obj在同一個package中(不符合業務邏輯，但作者看過的幾個第三方包中的確有將所有代碼寫在一個package甚至一個文件中的情況)。
之所以在此綁定了Objstruct而非Objectinterface，是因為我們只創建了一個Objectinterface的實例，省去了賦值（給interface賦struct）的麻煩。具體而言，標準庫中的package context中timerCtx綁定的是cancelCtx這一個struct。

//context.go
package context

type Context interface {
    //......
}

type cancelCtx struct {
    Context
    mu       sync.Mutex            // protects following fields
    done     chan struct{}         // created lazily, closed by first cancel call
    children map[canceler]struct{} // set to nil by the first cancel call
    err      error                 // set to non-nil by the first cancel call
}

type timerCtx struct {
    cancelCtx          //construct struct by embedding struct
    timer *time.Timer   // Under cancelCtx.mu.
    deadline time.Time
}

func (c *timerCtx) cancel(removeFromParent bool, err error) {
    c.cancelCtx.cancel(false, err)  //具體調用
    //......

需要注意的是，具體調用是、timerCtx調用(cancelCtx.cancel)的方法，而非(timerCtx.cancelCtx)調用cancel方法。(很基礎但很重要)

而如果我們在父類實現多個GetID的方法，并希望在子類中加以選擇，那么我們就需要創建兩個struct并分別實現不同的方法，使用construct struct by embedding interface來決定綁定哪一個struct。另外，如果使用construct struct by embedding interface，則不可以越過父類的方法(如果存在的話)去執行爺類(???)定義的方法。
為什么說在不同package下不公開struct（即struct obj）不可行，因為不是在同一個package中進行賦值。也就是說必須公開對外可見后，外部才得以使用他來賦值。而使用NewObj(...)作包裹從本質而言也是一個道理。
最后我們給出Monster的代碼，可以發現，他只需要實現自己獨有的方法即可。當然它也可以有選擇性的override父類的方法：

//object/creature/monster/monster.go
package monster
import (
    "fmt"
    "github.com/ovenvan/multi-inheritance/object"
    "github.com/ovenvan/multi-inheritance/object/creature"
)
type Monster interface {
    creature.Creature
    Hatch()
}
type Monster_s struct {
    creature.Crea
    alive bool
}
func (t *Monster_s) Hatch(){
    t.Create()
    fmt.Println("After created, i was hatched")
}
func (t *Monster_s) Create(){
    t.Crea.Create()
    fmt.Println("This is an Override Create Method from monster")
}
func (t *Monster_s)GetID() uint{
    fmt.Println("Override GetID from Monster")
    //return t.Crea.GetID()
    return t.Obj.GetID()        //直接調用父類的父類(Obj)的方法，
                                //跳過了Creature重寫的方法。
    //t.GetID()  recursive call
}

func NewMonster (m object.ObjectManager) Monster{...}

最后看一下main.go:

package main

import (
    "github.com/ovenvan/multi-inheritance/object/creature/monster"
)

func main() {
    mstr:=monster.NewMonster()
    mstr.Hatch()
}

我在Github-multi-inheritance上傳了本次實驗的Demo，包括完善了各函數的代碼，大家可以通過

go get github.com/ovenvan/multi-inheritance

下載該Demo并提出修改意見。