在golang中，采用匿名結(jié)構(gòu)體字段來模擬繼承關(guān)系。這個時候，可以說 Student 是繼承自 Person .

type Person struct {
    name string
    age int
    sex string
}
func (Person) SayHello(){
 fmt.Println("this is from Person")
}
type Student struct {
    Person
    school string
}
func main() {
    stu := Student{school:"middle"}
    stu.name = "leo"
    stu.age = 30
    fmt.Println(stu.name) //這里其實就是這樣做了一層轉(zhuǎn)換stu.Person.name
    stu.SayHello() //也做了轉(zhuǎn)換
}

可以看到繼承之后的結(jié)構(gòu)體擁有繼承結(jié)構(gòu)體的屬性和方法。其實本質(zhì)上是嵌套關(guān)系，它幫你簡化了。

定義

結(jié)構(gòu)體可以包含一個或多個 匿名（或內(nèi)嵌）字段，即這些字段沒有顯式的名字，只有字段的類型是必須的，此時類型就是字段的名字。匿名字段本身可以是一個結(jié)構(gòu)體類型，即 結(jié)構(gòu)體可以包含內(nèi)嵌結(jié)構(gòu)體。

可以粗略地將這個和面向?qū)ο笳Z言中的繼承概念相比較，隨后將會看到它被用來模擬類似繼承的行為。Go 語言中的繼承是通過內(nèi)嵌或組合來實現(xiàn)的，所以可以說，在 Go 語言中，相比較于繼承，組合更受青睞。

考慮如下的程序：

package main
import "fmt"
type innerS struct {
    in1 int
    in2 int
}
type outerS struct {
    b    int
    c    float32
    int  // anonymous field
    innerS //anonymous field
}
func main() {
    outer := new(outerS)
    outer.b = 6
    outer.c = 7.5
    outer.int = 60
    outer.in1 = 5
    outer.in2 = 10
    fmt.Printf("outer.b is: %d\n", outer.b)
    fmt.Printf("outer.c is: %f\n", outer.c)
    fmt.Printf("outer.int is: %d\n", outer.int)
    fmt.Printf("outer.in1 is: %d\n", outer.in1)
    fmt.Printf("outer.in2 is: %d\n", outer.in2)
    // 使用結(jié)構(gòu)體字面量
    outer2 := outerS{6, 7.5, 60, innerS{5, 10}}
    fmt.Println("outer2 is:", outer2)
}

輸出：

outer.b is: 6
outer.c is: 7.500000
outer.int is: 60
outer.in1 is: 5
outer.in2 is: 10
outer2 is:{6 7.5 60 {5 10}}

通過類型 outer.int 的名字來獲取存儲在匿名字段中的數(shù)據(jù)，于是可以得出一個結(jié)論：在一個結(jié)構(gòu)體中對于每一種數(shù)據(jù)類型只能有一個匿名字段。

內(nèi)嵌結(jié)構(gòu)體

同樣地結(jié)構(gòu)體也是一種數(shù)據(jù)類型，所以它也可以作為一個匿名字段來使用，如同上面例子中那樣。外層結(jié)構(gòu)體通過 outer.in1 直接進入內(nèi)層結(jié)構(gòu)體的字段，內(nèi)嵌結(jié)構(gòu)體甚至可以來自其他包。內(nèi)層結(jié)構(gòu)體被簡單的插入或者內(nèi)嵌進外層結(jié)構(gòu)體。這個簡單的 “繼承” 機制提供了一種方式，使得可以從另外一個或一些類型繼承部分或全部實現(xiàn)。

另外一個例子：

示例 10.9 embedd_struct.go：

package main
import "fmt"
type A struct {
    ax, ay int
}
type B struct {
    A
    bx, by float32
}
func main() {
    b := B{A{1, 2}, 3.0, 4.0}
    fmt.Println(b.ax, b.ay, b.bx, b.by)
    fmt.Println(b.A)
}

輸出：

1 2 3 4
{1 2}

命名沖突

當兩個字段擁有相同的名字（可能是繼承來的名字）時該怎么辦呢？

• 外層名字會覆蓋內(nèi)層名字（但是兩者的內(nèi)存空間都保留），這提供了一種重載字段或方法的方式；
• 如果相同的名字在同一級別出現(xiàn)了兩次，如果這個名字被程序使用了，將會引發(fā)一個錯誤（不使用沒關(guān)系）。沒有辦法來解決這種問題引起的二義性，必須由程序員自己修正。

例子：

type A struct {a int}
type B struct {a, b int}
type C struct {A; B}
var c C

規(guī)則 2：使用 c.a 是錯誤的，到底是 c.A.a 還是 c.B.a 呢？會導致編譯器錯誤：ambiguous DOT reference c.a disambiguate with either c.A.a or c.B.a。

type D struct {B; b float32}
var d D

規(guī)則 1：使用 d.b 是沒問題的：它是 float32，而不是 B 的 b。如果想要內(nèi)層的 b 可以通過 d.B.b 得到。

到此這篇關(guān)于Go語言中Struct繼承與匿名字段和內(nèi)嵌結(jié)構(gòu)體全面詳解的文章就介紹到這了,更多相關(guān)Go Struct繼承內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論