golang tiada kelas

Objek dan kelas dalam bahasa Go

Antara banyak bahasa pengaturcaraan, Pengaturcaraan Berorientasikan Objek (OOP) ialah paradigma pengaturcaraan popular yang membungkus data dan kaedah bersama-sama untuk mencipta kod modular yang boleh digunakan semula. Dalam bahasa OOP tradisional (seperti Java, C++, dll.), kelas ialah salah satu konsep teras OOP. Ciri-ciri seperti enkapsulasi, pewarisan, dan polimorfisme boleh dicapai melalui kelas. Tetapi dalam bahasa Go, tiada kata kunci kelas dan OOP dalam bahasa Go berbeza daripada bahasa OOP tradisional dalam banyak cara.

Berorientasikan objek dalam bahasa Go

Dalam bahasa Go, pelaksanaan berorientasikan objek terutamanya direalisasikan melalui struktur (Struct) dan kaedah (Kaedah ini boleh digabungkan dengan struktur Persatuan untuk membentuk). sesuatu objek. Dalam bahasa Go, struktur ditakrifkan dengan cara yang sama, dan ia juga boleh mengandungi pembolehubah ahli dan kaedah ahli.

Struktur Go yang ringkas ditakrifkan seperti berikut:

type Person struct {
    Name    string
    Age     int
    Address string
}

Dalam contoh ini, kami mentakrifkan struktur bernama Person, yang mengandungi tiga medan: Nama, Umur dan Alamat . Pembolehubah ahli struktur ini boleh diakses melalui sintaks ".", contohnya:

var person Person
person.Name = "Tom"
person.Age = 20
person.Address = "New York"

Dengan cara ini, kami mencipta contoh bernama orang, dan medan di dalamnya boleh diakses melalui ".".

Melalui struktur, kita boleh menentukan atribut (pembolehubah ahli) bagi contoh, tetapi bagaimana untuk mengendalikan tika? Dalam bahasa Go, anda boleh menentukan kaedah untuk struktur dan mengendalikan pembolehubah ahli struktur dalam kaedah tersebut.

Kaedah Go mudah ditakrifkan seperti berikut:

func (p *Person) GetAge() int {
    return p.Age
}

Dalam contoh ini, kami mentakrifkan kaedah yang dipanggil GetAge, yang mengembalikan umur (Umur) contoh struktur semasa. Perlu diingatkan bahawa kaedah ini menggunakan penerima jenis penunjuk, yang bermaksud ia boleh mengubah suai sifat contoh struktur.

Penciptaan dan penggunaan objek

Cara untuk mencipta objek dalam bahasa Go juga berbeza daripada bahasa OOP lain. Dalam bahasa OOP tradisional, kita boleh mencipta objek melalui kata kunci seperti "baru" atau "pembina". Tetapi dalam bahasa Go, kita hanya perlu mencipta contoh melalui definisi struktur, dan kemudian menghantar penunjuk contoh kepada kaedah untuk operasi.

Contoh mudah untuk mencipta dan menggunakan objek Go adalah seperti berikut:

var person *Person = new(Person)
person.Name = "Tom"
person.Age = 20
person.Address = "New York"
fmt.Println("The age of person is", person.GetAge()) // 输出 The age of person is 20

Dalam contoh ini, kita mula-mula mencipta tika bernama orang melalui fungsi new() dan kemudian menetapkan sifatnya. Akhir sekali, kami memanggil kaedah GetAge() orang itu untuk mendapatkan umur orang itu.

Perlu diambil perhatian bahawa dalam bahasa Go, anda boleh menggunakan operator "&" untuk mendapatkan penunjuk pembolehubah, contohnya:

var person Person
var p *Person = &person

Di sini, kami mula-mula mentakrifkan pembolehubah bernama orang Contoh struktur, kemudian gunakan operator "&" untuk mendapatkan penunjuknya, dan tetapkan penunjuk kepada pembolehubah p. Anda juga boleh terus menggunakan operator "&" untuk mendapatkan penunjuk contoh struktur yang baru dibuat, contohnya:

var p *Person = &Person{}

Dengan cara ini, kami mencipta objek Orang bernama p dan menetapkan penunjuknya kepada pembolehubah p .

Warisan dan polimorfisme

Dalam bahasa OOP tradisional, pewarisan dan polimorfisme ialah dua ciri yang sangat penting. Mereka boleh meningkatkan kebolehgunaan semula kod dan fleksibiliti. Walau bagaimanapun, dalam bahasa Go, kerana tiada kata kunci kelas, pelaksanaan pewarisan dan polimorfisme agak berbeza.

Dalam bahasa Go, pewarisan dilaksanakan melalui "Struct Terbenam". Ini sangat serupa dengan warisan dalam bahasa Java, tetapi tidak seperti Java, struktur bersarang dalam bahasa Go tidak mewarisi semua ahli struktur induk secara lalai.

Contoh struktur Go bersarang mudah adalah seperti berikut:

type Driver struct {
    Name string
}

type Car struct {
    *Driver
    Brand string
}

func (d *Driver) Drive() {
    fmt.Println(d.Name, "is driving")
}

func main() {
    var john *Driver = &Driver{Name: "John"}
    var benz *Car = &Car{Driver: john, Brand: "Benz"}
    benz.Drive() // 输出 John is driving
}

Dalam contoh ini, kami mentakrifkan struktur bernama Pemandu dan struktur bernama Pemandu bersarang dalam Kereta. Struktur Pemandu mempunyai kaedah yang dipanggil Drive, yang digunakan untuk mengeluarkan nama pemandu. Kita dapat melihat bahawa Pemandu bersarang di dalam Kereta, dan kaedah Pemandu Pemandu boleh dipanggil melalui contoh Kereta. Ini melaksanakan pewarisan mudah.

Dalam bahasa Go, polimorfisme boleh dilaksanakan menggunakan kaedah "Antara Muka". Berbeza daripada bahasa OOP tradisional seperti Java, pelaksanaan antara muka ditakrifkan oleh kata kunci "implements" (seperti kata kunci "implements" dalam Java), yang dilaksanakan secara tersirat dalam bahasa Go. Anda hanya perlu menentukan set kaedah Selagi jenis yang melaksanakan set kaedah ini boleh melaksanakan antara muka, tidak perlu mengisytiharkan secara eksplisit bahawa ia melaksanakan antara muka.

Contoh antara muka Go yang ringkas adalah seperti berikut:

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "Meow!"
}

func main() {
    var animal Animal = Dog{}
    fmt.Println(animal.Speak()) // 输出 Woof!
    animal = Cat{}
    fmt.Println(animal.Speak()) // 输出 Meow!
}

Dalam contoh ini, kami mentakrifkan antara muka bernama Animal dan kaedah bernama Speak di dalamnya. Kami juga mencipta dua jenis, Anjing dan Kucing, yang kedua-duanya melaksanakan antara muka Haiwan. Akhir sekali, kami menggunakan sifat dinamik antara muka haiwan, menetapkannya kepada contoh jenis Anjing dan Kucing, dan memanggil kaedah Sebut yang sepadan. Seperti yang anda lihat, melalui antara muka, kami telah mencapai polimorfisme mudah.

Ringkasan

Walaupun tiada kata kunci kelas dalam bahasa Go, melalui gabungan struktur dan kaedah, kami juga boleh mencapai pengaturcaraan berorientasikan objek, termasuk ciri seperti pengkapsulan, pewarisan dan polimorfisme. Dan kerana tiada kerumitan kelas, pengaturcaraan berorientasikan objek dalam bahasa Go adalah lebih ringkas dan fleksibel. Pada masa yang sama, bahasa Go juga menyediakan ciri seperti antara muka dan struct terbenam untuk melaksanakan polimorfisme dan warisan. Ciri-ciri ini membolehkan bahasa Go mengekalkan kesederhanaan dan kecekapan bahasa semasa melaksanakan OOP.

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