Cara mewarisi dalam golang

Dalam bahasa Go, tiada "kelas" yang ditakrifkan dalam bahasa berorientasikan objek tradisional, jadi tiada apa yang dipanggil "warisan". Walau bagaimanapun, bahasa Go menyediakan kaedah untuk mencapai warisan yang serupa melalui gubahan, yang dipanggil Embedding.

Pembenaman membolehkan kami membenamkan jenis ke dalam jenis lain, supaya jenis terbenam boleh mengakses terus sifat dan kaedah jenis di mana ia dibenamkan tanpa perlu mengaksesnya melalui antara muka atau cara lain. Proses ini serupa dengan "warisan" tradisional, tetapi lebih fleksibel.

Di bawah, kami akan menggunakan beberapa contoh untuk menunjukkan cara menggunakan pembenaman untuk mencapai fungsi seperti warisan.

1. Contoh asas

Kami mula-mula mentakrifkan beberapa struktur asas, anjing, kucing dan manusia:

type Dog struct {
    name string
}

func (d Dog) Bark() {
    fmt.Println(d.name, ": 汪汪汪！")
}

type Cat struct {
    name string
}

func (c Cat) Mew() {
    fmt.Println(c.name, ": 喵喵喵！")
}

type Person struct {
    name string
}

func (p Person) Speak() {
    fmt.Println(p.name, ": 你好！")
}

Sekarang kami ingin mencipta Jenis haiwan, yang boleh "mewarisi" anjing dan kucing, dan juga mempunyai sifat dan kaedahnya sendiri, seperti warna dan kelajuan larian. Kita boleh mentakrifkannya seperti ini:

type Animal struct {
    Dog
    Cat
    color       string
    runSpeed    int
}

func (a Animal) Run() {
    fmt.Println(a.color, "的动物以", a.runSpeed, "km/h的速度奔跑！")
}

Dalam takrifan ini, jenis Haiwan membenamkan jenis Anjing dan Kucing. Ini bermakna objek yang dibuat instantiated daripada jenis Haiwan boleh terus mengakses sifat dan kaedah jenis Anjing dan Kucing. Kami juga boleh mentakrifkan sifat dan kaedah kami sendiri untuk jenis Haiwan, seperti warna dan kelajuan lari, untuk mewakili warna haiwan dan kelajuan larian, dan mentakrifkan kaedah Larian untuk menerangkan tindakan larian haiwan.

Sekarang mari kita cipta objek Haiwan dan lihat cara ia berfungsi:

func main() {
    d := Dog{name: "小黑"}
    c := Cat{name: "小白"}
    a := Animal{d, c, "黑白相间", 50}
    a.Bark()    // 小黑 : 汪汪汪！
    a.Mew()     // 小白 : 喵喵喵！
    a.Run()     // 黑白相间 的动物以 50 km/h的速度奔跑！
}

Kita dapat melihat bahawa dengan membenamkan jenis Anjing dan Kucing, objek Haiwan boleh terus memanggil kaedah Bark dan Mew , tanpa menggunakan antara muka atau cara lain. Pendekatan ini membolehkan kami mencapai fungsi yang serupa tanpa menggunakan "warisan" dalam erti kata tradisional.

2. Jenis tersuai terbenam

Kami boleh membenamkan jenis tersuai ke dalam jenis tersuai lain untuk mencapai kesan yang serupa dengan warisan. Sekarang, mari kita tentukan jenis Orang dan jenis Pelajar, dan benamkan jenis Orang ke dalam jenis Pelajar:

type Person struct {
    name string
    age  int
    sex  string
}

type Student struct {
    Person
    class string
    score float64
}

Dalam takrifan ini, jenis Pelajar membenamkan jenis Orang. Apabila menghidupkan objek jenis Pelajar, anda boleh menggunakan sifat dan kaedah Orang. Sebagai contoh, kita boleh membuat instantiate objek pelajar dan menetapkan nama, umur, jantina, kelas dan grednya:

func main() {
    s := Student{
        Person: Person{
            name: "小明",
            age:  18,
            sex:  "男",
        },
        class: "高三一班",
        score: 92.5,
    }
    fmt.Println("姓名：", s.name)
    fmt.Println("年龄：", s.age)
    fmt.Println("性别：", s.sex)
    fmt.Println("班级：", s.class)
    fmt.Println("成绩：", s.score)
}

Apabila kita menjalankan program ini, kita boleh melihat output berikut:

姓名： 小明
年龄： 18
性别： 男
班级： 高三一班
成绩： 92.5

Kami boleh melihat bahawa objek Pelajar boleh terus mengakses sifat dan kaedah objek jenis Orang, termasuk atribut seperti nama, umur dan jantina.

3. Pembenaman Bersarang

Ia juga mungkin untuk menyarangkan berbilang jenis dalam satu jenis. Kita boleh membenamkan jenis Haiwan ke dalam jenis lain untuk mencapai lebih banyak fungsi. Sebagai contoh, mari kita tentukan jenis Zoo:

type Zoo struct {
    Animal
    name    string
    address string
}

func (z Zoo) ShowInfo() {
    fmt.Println("这是", z.name, ", 地址是", z.address)
    z.Run()
}

Dalam takrif jenis ini, kami membenamkan jenis Haiwan ke dalam jenis Zoo. Dengan cara ini, jenis Zoo boleh terus mengakses sifat dan kaedah jenis Haiwan, termasuk kaedah Run. Kami menentukan kaedah ShowInfo lain untuk mengeluarkan nama dan alamat zoo, dan memanggil kaedah Run jenis Haiwan untuk menunjukkan haiwan berlari.

Sekarang, kami mencipta objek Zoo dan menguji kaedahnya:

func main() {
    d := Dog{name: "小黑"}
    c := Cat{name: "小白"}
    a := Animal{d, c, "黑白相间", 50}
    z := Zoo{a, "北京动物园", "北京市海淀区清华科技园路"}
    z.ShowInfo()
}

Apabila kami menjalankan program ini, kami dapat melihat output adalah seperti berikut:

这是 北京动物园 , 地址是 北京市海淀区清华科技园路
黑白相间 的动物以 50 km/h的速度奔跑！

Kami dapat melihat Dengan menyarangkan jenis Haiwan ke dalam jenis Zoo, kita boleh mencipta jenis dengan lebih banyak fungsi yang boleh memaparkan maklumat zoo dan tindakan berjalan haiwan.

Ringkasan

Walaupun bahasa Go tidak mempunyai konsep kelas dan warisan yang ditakrifkan oleh bahasa berorientasikan objek tradisional, konsep pembenaman membolehkan kami Mencapai fungsi yang serupa dengan lebih fleksibiliti dan kemudahan. Melalui contoh di atas, kita dapat melihat bahawa pembenaman memudahkan untuk mencipta jenis yang mengandungi subjenis dan memanggil kaedah dan sifatnya dengan mudah.

Atas ialah kandungan terperinci Cara mewarisi dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!