Bagaimana untuk menggunakan berbilang warisan dalam Go?

Dalam pengaturcaraan berorientasikan objek, warisan ialah konsep penting, yang membolehkan kami menggunakan semula kod sedia ada dengan lebih mudah. Walau bagaimanapun, dalam beberapa kes, kita memerlukan kelas untuk diwarisi daripada berbilang kelas induk pada masa yang sama. Ini ialah konsep warisan berbilang. Walaupun pewarisan berbilang berguna, ia tidak mudah untuk dilaksanakan dalam beberapa bahasa pengaturcaraan Contohnya, Java dan C# kedua-duanya melarang pewarisan berbilang.

Sebaliknya, bahasa Go menyediakan cara mudah untuk menggunakan berbilang warisan Artikel ini akan memperkenalkan cara menggunakan berbilang warisan dalam Go.

Bahasa Go dan berbilang warisan

Dalam Go, kami boleh melaksanakan berbilang warisan melalui pembenaman. Benamkan ialah perhubungan gabungan dalam bahasa Go, yang boleh membenamkan satu jenis ke jenis lain untuk mencapai pengembangan jenis.

Sintaks untuk membenam adalah sangat mudah, hanya gunakan nama satu jenis dalam takrif jenis lain. Contohnya, jika kita mempunyai jenis A dan jenis B yang lain, kita boleh membenamkan B ke dalam A seperti berikut:

type A struct {
  B
}

Dengan cara ini, jenis A boleh mengakses semua medan dan kaedah dalam jenis B. Jika terdapat kaedah yang dipanggil foo() dalam B, maka kaedah ini juga boleh dipanggil dalam A melalui a.foo().

Kaedah ini seperti "membenamkan" jenis B ke dalam jenis A, membenarkan A untuk memiliki fungsi B secara langsung. Jika B membenamkan jenis C pada masa yang sama, maka A mempunyai fungsi kedua-dua B dan C. Kaedah ini ialah warisan berbilang dalam bahasa Go.

Kod Contoh

Mari kita lihat contoh, andaikan kita mempunyai tiga jenis yang perlu digunakan semula: Rect, Circle dan Shape. Rect dan Bulatan masing-masing mewakili segi empat tepat dan bulatan, dan Bentuk mewakili sebarang bentuk.

Kami ingin mencipta jenis yang dipanggil ColoredShape, yang mempunyai kedua-dua kefungsian Shape dan kefungsian untuk mewarna. Kami boleh menggunakan pembenaman untuk melaksanakan berbilang warisan Kod sampel adalah seperti berikut:

type Shape struct {}

func (s *Shape) Area() float64 {
  return 0
}

type Rect struct {
  width, height float64
}

func (r *Rect) Area() float64 {
  return r.width * r.height
}

type Circle struct {
  radius float64
}

func (c *Circle) Area() float64 {
  return math.Pi * c.radius * c.radius
}

type Colored struct {
  color string
}

type ColoredShape struct {
  Shape
  Colored
}

func main() {
  cs := ColoredShape{Shape{}, Colored{"red"}}
  fmt.Println(cs.Area())
}

Dalam kod di atas, kami mentakrifkan tiga jenis: Bentuk, Rect dan Bulatan. Setiap jenis mempunyai kaedah Kawasan(), yang digunakan untuk mengira kawasannya. Kemudian kami menentukan jenis Berwarna, yang mengandungi sifat warna. Akhir sekali, kami mentakrifkan jenis ColoredShape, yang membenamkan Shape dan Colored dan boleh mengira kawasannya sendiri. Dalam fungsi main(), kami mencipta contoh ColoredShape dengan atribut merah dan memanggil kaedah Area()nya.

Ringkasan

Dalam artikel ini, kami telah mempelajari cara menggunakan berbilang warisan dalam bahasa Go. Melalui pembenaman, kami boleh menggabungkan berbilang jenis dengan mudah untuk menggunakan semula kod sedia ada dan menambah fungsi baharu pada program kami. Warisan berbilang ialah teknik pengaturcaraan yang berguna, tetapi ia perlu digunakan dengan berhati-hati untuk mengelakkan peningkatan kerumitan dan menjadikan kod lebih sukar untuk dikekalkan.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan berbilang warisan dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!