Prinsip pelaksanaan objek dan kelas dalam bahasa Go

Go ialah bahasa pengaturcaraan yang ditaip secara statik, tetapi tidak seperti bahasa pengaturcaraan lain, ia tidak menyediakan konsep kelas. Ini membuatkan ramai pemula keliru apabila mempelajari Go dan tidak tahu cara melaksanakan pengaturcaraan berorientasikan objek dalam Go.

Walau bagaimanapun, walaupun Go tidak mempunyai konsep kelas, ia menyediakan beberapa teknik yang boleh digunakan untuk melaksanakan orientasi objek. Teknik ini tidak semestinya dipanggil "kelas", tetapi ia mempunyai tujuan yang sama.

Bahasa Go menggunakan struktur untuk menerangkan objek dan struktur mengandungi data dan kaedah. Kaedah ini adalah fungsi ahli struktur, dan mereka boleh mengakses pembolehubah ahli dan fungsi lain struktur.

Contohnya:

type User struct {
    Name string
    Age  int
}

func (user *User) SayHello() {
    fmt.Printf("Hi, my name is %v and I am %v years old.", user.Name, user.Age)
}

func main() {
    me := User{"Alice", 25}
    me.SayHello()
}

Dalam contoh di atas, kami mentakrifkan struktur bernama Pengguna, yang mengandungi dua medan: Nama dan Umur. Kami juga mentakrifkan fungsi SayHello, yang merupakan fungsi ahli struktur Pengguna. Fungsi ini mempunyai akses kepada medan Nama dan Umur dalam struktur Pengguna dan boleh menggunakannya untuk mengeluarkan beberapa maklumat.

Dalam fungsi utama, kami mencipta objek Pengguna bernama saya dan kemudian memanggil kaedah SayHellonya. Dengan cara ini, ia akan mengeluarkan mesej yang mengandungi nama dan umur objek Pengguna.

Setakat ini, kami telah melihat satu cara untuk melaksanakan objek dalam Go. Walaupun kaedah ini tidak mempunyai konsep kelas, ia lebih mudah daripada kelas dalam beberapa bahasa pengaturcaraan berorientasikan objek lain.

Sudah tentu, ini bukan satu-satunya cara. Go juga menyediakan beberapa ciri yang lebih maju, seperti antara muka dan komposisi.

Antara muka ialah jenis yang serupa dengan fungsi umum, yang tidak mengandungi datanya sendiri. Sebaliknya, ia mentakrifkan satu set kaedah yang boleh dilaksanakan oleh jenis struct. Ini membolehkan kami menganggap jenis yang berbeza sebagai jenis yang sama asalkan mereka melaksanakan set kaedah yang sama.

Contohnya:

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2*r.Width + 2*r.Height
}

func main() {
    r := Rectangle{3, 4}
    fmt.Println("Area:", r.Area(), "Perimeter:", r.Perimeter())
}

Dalam contoh di atas, kami menentukan antara muka bernama Shape, yang mempunyai dua kaedah: Luas dan Perimeter. Kami juga mentakrifkan struktur yang dipanggil Rectangle, yang mempunyai dua medan: Lebar dan Tinggi. Kami membuat jenis Rectangle melaksanakan antara muka Bentuk, yang bermaksud ia mesti melaksanakan kaedah Kawasan dan Perimeter.

Dalam fungsi utama, kami mencipta objek Segiempat dan kemudian memanggil kaedah Luas dan Perimeternya. Kedua-dua kaedah diwarisi daripada antara muka Shape, jadi kita boleh memanggil kaedah jenis Rectangle sama seperti jenis Shape.

Ini ialah penggunaan biasa antara muka dalam Go, yang membolehkan kami menerangkan jenis melalui set kaedah tanpa menyatakan jenis pelaksanaan tertentu. Ini memberikan abstraksi Go dengan fleksibiliti yang hebat.

Akhir sekali, Go juga memberikan kami ciri gubahan yang berkuasa. Komposisi ialah kaedah menggabungkan pelbagai jenis menjadi jenis baharu. Jenis ini boleh menjadi struktur atau antara muka.

Contohnya:

type Person struct {
    Name string
    Age  int
}

func (p Person) SayHello() {
    fmt.Printf("Hi, my name is %v and I am %v years old.", p.Name, p.Age)
}

type Employee struct {
    Person
    Salary float64
}

func main() {
    e := Employee{Person{"Alice", 25}, 50000}
    e.SayHello()
}

Dalam contoh di atas, kami mentakrifkan struktur bernama Orang, yang mempunyai dua medan: Nama dan Umur. Kami juga mentakrifkan kaedah SayHello, yang boleh digunakan untuk mengeluarkan maklumat Orang.

Kemudian, kami mentakrifkan struktur bernama Pekerja, yang mengandungi medan Orang dan medan Gaji. Ini bermakna jenis Pekerja sudah termasuk semua medan dan kaedah jenis Orang.

Dalam fungsi utama, kami mencipta objek Pekerja bernama e dan kemudian memanggil kaedah SayHellonya. Memandangkan Pekerja sudah mengandungi jenis Orang, kita boleh terus memanggil kaedah SayHello Pekerja sama seperti memanggil Orang.

Ini ialah gubahan dalam Go, ia memberi kita cara untuk menggunakan semula kod sambil memastikan ia bersih dan boleh dibaca.

Ringkasnya, walaupun Go tidak mempunyai konsep kelas, ia menyediakan banyak teknologi yang boleh digunakan untuk melaksanakan pengaturcaraan berorientasikan objek, seperti struktur, kaedah, antara muka dan gabungan. Teknologi ini menjadikan pengaturcaraan berorientasikan objek Go mudah dan fleksibel, sambil mengekalkan ciri dan kelebihan bahasa Go.

Atas ialah kandungan terperinci Prinsip pelaksanaan objek dan kelas dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!