pelaksanaan lalai antara muka golang

Untuk menjadikan kod lebih fleksibel dan berskala, selalunya perlu menggunakan antara muka untuk pembangunan. Dalam bahasa Go, antara muka ialah ciri bahasa yang sangat berkuasa yang menyokong berbilang struktur untuk melaksanakan antara muka yang sama.

Walau bagaimanapun, pada masa lalu, bahasa Go tidak menyokong pelaksanaan lalai antara muka, yang bermaksud bahawa apabila melaksanakan antara muka, semua kaedah antara muka mesti dilaksanakan. Apabila anda perlu mewarisi antara muka, anda perlu melaksanakan kaedah yang sama berulang kali dalam sub-antara muka, yang menghasilkan tahap pertindihan kod yang tinggi dan tidak kondusif untuk pengembangan dan penyelenggaraan kod.

Untuk menyelesaikan masalah ini, bermula daripada bahasa Go versi 1.8, sokongan untuk pelaksanaan lalai antara muka disediakan. Ciri ini membolehkan kami mentakrifkan pelaksanaan lalai kaedah dalam antara muka, supaya hanya kaedah yang diperlukan perlu dilaksanakan semasa melaksanakan antara muka.

Sintaks pelaksanaan lalai antara muka

Sintaks pelaksanaan lalai antara muka adalah sangat mudah Anda hanya perlu menambah kata kunci lalai sebelum pelaksanaan kaedah. Contohnya:

taip antara muka Pembaca {

Read(p []byte) (n int, err error)
default Close() error {
    return nil
}

}

Dalam contoh ini, antara muka Pembaca mentakrifkan kaedah Baca dan pelaksanaan lalai bagi kaedah Tutup. Jika antara muka Pembaca dilaksanakan tetapi kaedah Tutup tidak dilaksanakan, sistem akan menggunakan kaedah Tutup lalai.

Perlu diambil perhatian bahawa jika antara muka mentakrifkan kaedah pelaksanaan lalai, maka anda hanya perlu melaksanakan kaedah bukan lalai apabila melaksanakan antara muka. Jika anda ingin mengatasi kaedah pelaksanaan lalai, anda boleh menentukan kaedah dengan nama yang sama dalam struktur yang melaksanakan antara muka untuk menggantikan pelaksanaan lalai.

Senario aplikasi untuk pelaksanaan lalai antara muka

Senario penggunaan untuk pelaksanaan lalai antara muka adalah sangat luas Di bawah kami akan memperkenalkan beberapa senario aplikasi biasa.

1. Sarang antara muka

Dalam bahasa Go, sarang antara muka ialah teknologi yang sangat biasa. Antara muka bersarang boleh menjadikan kod lebih fleksibel dan lebih teratur.

Andaikan kita mempunyai antara muka yang perlu membaca dan menulis fail:

taip antara muka FileReadWrite {

Read(p []byte) (n int, err error)
Write(p []byte) (n int, err error)

}

Seterusnya kita tentukan antara muka yang memerlukan untuk menutup fail :

taip antara muka Boleh Ditutup {

Close() error

}

Jika kita ingin mentakrifkan antara muka operasi fail, termasuk kaedah membaca, menulis dan menutup fail, kita boleh gunakan antara muka bersarang Kaedah:

taip antara muka FileOperation {

FileReadWrite
Closeable

}

Menggunakan pelaksanaan lalai boleh mengelakkan berulang kali melaksanakan kaedah Tutup apabila melaksanakan antara muka Operasi Fail.

2. Naik taraf versi antara muka

Semasa proses pembangunan, peningkatan versi antara muka sering ditemui. Apabila kita perlu menambah kaedah pada antara muka, jika kita mengubah suai antara muka asal secara langsung, semua kod yang telah melaksanakan antara muka perlu diubah suai.

Dengan menggunakan pelaksanaan lalai, kami boleh menambah kaedah baharu pada antara muka tanpa melanggar kod sedia ada. Jika anda perlu menggunakan kaedah baharu, anda boleh mengatasi kaedah pelaksanaan lalai dalam struktur yang melaksanakan antara muka.

3. Corak penyesuai antara muka

Corak penyesuai ialah corak reka bentuk biasa yang digunakan untuk menukar antara muka kelas kepada antara muka lain untuk memudahkan Interaksi yang tidak disokong antara kelas antara muka ini.

Dalam bahasa Go, kami boleh menggunakan pelaksanaan lalai antara muka untuk melaksanakan corak penyesuai dengan cepat. Berikut ialah contoh mudah:

taip antara muka USB {

Connect()
DataTransfer(data string) string

}

taip Adapte struct {}

func (a *Adaptee) OldInterface( ) {

fmt.Println("support old interface")

}

taip antara muka Penyesuai {

USB

}

taip AdapterImpl struct {

Adaptee

}

func (a *AdapterImpl) Connect() {

fmt.Println("connect USB")

}

func (a *AdapterImpl) DataTransfer(rentetan data) {

fmt.Println("transfer data through USB")
a.OldInterface()  
return "Result"

}

Dalam contoh ini, kami mentakrifkan antara muka USB dan Adapte antara muka lama untuk menunjukkan penggunaan penyesuai. Untuk membolehkan Adapte menggunakan antara muka USB, kami menentukan penyesuai yang melaksanakan antara muka Penyesuai.

Sambung dan Pemindahan Data dalam penyesuai menggunakan pelaksanaan lalai. Kaedah OldInterface Adaptee dipanggil dalam pelaksanaan lalai. Dengan cara ini, kita boleh menggunakan penyesuai untuk menukar kelas yang tidak menyokong antara muka USB kepada kelas yang menyokong antara muka USB.

Ringkasan

Pelaksanaan lalai antara muka dalam bahasa Go ialah ciri bahasa yang sangat praktikal. Ia membolehkan kami mentakrifkan antara muka dengan lebih fleksibel, sambil mengurangkan pertindihan kod dan meningkatkan kualiti kod. Melalui penggunaan pelaksanaan lalai antara muka, kita boleh lebih mudah melaksanakan corak reka bentuk seperti penggunaan semula dan corak penyesuai.

Atas ialah kandungan terperinci pelaksanaan lalai antara muka golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!