[golang note] 匿名組合

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

匿名組合

       golang也提供了繼承機制，但採用組合的文法，因此稱為匿名組合。與其他語言不同， golang很清晰地展示出類的記憶體布局是怎樣的。

• 非指標方式組合

  基本文法

// 基類type Base struct {    // 成員變數}func (b *Base) 函數名(參數列表) (傳回值列表) {    // 函數體}// 衍生類別type Derived struct {    Base    // 成員變數}func (b *Derived) 函數名(參數列表) (傳回值列表) {    // 函數體}

  繼承規則

       √ 在衍生類別沒有改寫基類的成員方法時，相應的成員方法被繼承。

       √ 衍生類別可以直接調用基類的成員方法，譬如基類有個成員方法為Base.Func()，那麼Derived.Func()等同於Derived.Base.Func()

       √ 倘若衍生類別的成員方法名與基類的成員方法名相同，那麼基類方法將被覆蓋或叫隱藏，譬如基類和衍生類別都有成員方法Func()，那麼Derived.Func()將只能調用衍生類別的Func()方法，如果要調用基類版本，可以通過Derived.Base.Func()來調用。

樣本如下

package mainimport "fmt"type Base struct {}func (b *Base) Func1() {    fmt.Println("Base.Func1() was invoked!")}func (b *Base) Func2() {    fmt.Println("Base.Func2() was invoked!")}type Derived struct {    Base}func (d *Derived) Func2() {    fmt.Println("Derived.Func2() was invoked!")}func (d *Derived) Func3() {    fmt.Println("Derived.Func3() was invoked!")}func main() {    d := &Derived{}    d.Func1()      // Base.Func1() was invoked!    d.Base.Func1() // Base.Func1() was invoked!    d.Func2()      // Derived.Func2() was invoked!    d.Base.Func2() // Base.Func2() was invoked!    d.Func3() // Derived.Func3() was invoked!}

  記憶體布局

       √ golang很清晰地展示類的記憶體布局是怎樣的，即Base的位置即基類成員展開的位置。

       √ golang還可以隨心所欲地修改記憶體布局，即Base的位置可以出現在衍生類別的任何位置。

樣本如下

package mainimport "fmt"type Base struct {    BaseName string}func (b *Base) PrintName() {    fmt.Println(b.BaseName)}type Derived struct {    DerivedName string    Base}func (d *Derived) PrintName() {    fmt.Println(d.DerivedName)}func main() {    d := &Derived{}    d.BaseName = "BaseStruct"    d.DerivedName = "DerivedStruct"    d.Base.PrintName() // BaseStruct    d.PrintName()      // DerivedStruct}

• 指標方式組合

  基本文法

// 基類type Base struct {    // 成員變數}func (b *Base) 函數名(參數列表) (傳回值列表) {    // 函數體}// 衍生類別type Derived struct {    *Base    // 成員變數}func (b *Derived) 函數名(參數列表) (傳回值列表) {    // 函數體}

  繼承規則

       √ 基類採用指標方式的組合，依然具有派生的效果，只是衍生類別建立執行個體的時候需要外部提供一個基類執行個體的指標。

       √ 其他規則與非指標方式組合一致。

樣本如下

package mainimport (    "fmt"    "log"    "os")type MyJob struct {    Command string    *log.Logger}func (job *MyJob) Start() {    job.Println("job started!") // job.Logger.Println    fmt.Println(job.Command)    job.Println("job finished!") // job.Logger.Println}func main() {    logFile, err := os.OpenFile("./job.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0)    if err != nil {        fmt.Println("%s", err.Error())        return    }    defer logFile.Close()    logger := log.New(logFile, "[info]", log.Ldate|log.Ltime|log.Llongfile)    job := MyJob{"programming", logger}    job.Start()    job.Println("test finished!") // job.Logger.Println}

       在經過合適的賦值後，MyJob類型的所有成員方法可以很方便地借用所有log.Logger提供的方法。這對於MyJob的實現者來說，根本就不用意識到log.Logger類型的存在，這就是匿名組合的一個魅力所在。

一些總結

• 名字覆蓋

       上面說明了衍生類別成員方法名與基類成員方法名相同時基類方法將被覆蓋的情況，這對於成員變數名來說，規則也是一致的。

package mainimport "fmt"type Base struct {    Name string}type Derived struct {    Base    Name string}func main() {    d := &Derived{}    d.Name = "Derived"    d.Base.Name = "Base"    fmt.Println(d.Name)      // Derived    fmt.Println(d.Base.Name) // Base}

• 名字衝突

       匿名組合相當於以其類型名稱（去掉包名部分）作為成員變數的名字。那麼按此規則，類型中如果存在兩個同名的成員，即使類型不同，但我們預期會收到編譯錯誤。

package mainimport "log"type Logger struct {    Level int}type MyJob struct {    *Logger    Name string    *log.Logger // duplicate field Logger}func main() {    job := &MyJob{}}