Apakah hubungan antara jenis dan antara muka dalam bahasa Go

Dalam bahasa Go, terdapat hubungan satu-dengan-banyak dan banyak-dengan-satu antara jenis dan antara muka. Satu jenis boleh melaksanakan berbilang antara muka pada masa yang sama, dan antara muka adalah bebas antara satu sama lain dan tidak mengetahui pelaksanaan satu sama lain. Pelbagai jenis juga boleh melaksanakan antara muka yang sama: kaedah antara muka tidak semestinya perlu dilaksanakan sepenuhnya oleh jenis. Kaedah antara muka boleh dilaksanakan dengan membenamkan jenis atau struktur lain dalam jenis. Dalam erti kata lain, pengguna tidak peduli sama ada kaedah antara muka dilaksanakan sepenuhnya melalui satu jenis, atau sama ada ia dilaksanakan melalui berbilang struktur yang tertanam dalam struktur dan disatukan.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Hubungan antara jenis dan antara muka bahasa Go

Dalam bahasa Go, terdapat satu-dengan-banyak dan banyak-dengan-satu hubungan antara jenis dan antara muka Konsep biasa ini akan disenaraikan di bawah untuk memudahkan pembaca memahami hubungan pelaksanaan antara antara muka dan jenis dalam persekitaran yang kompleks.

Sesuatu jenis boleh melaksanakan berbilang antara muka

Sesuatu jenis boleh melaksanakan berbilang antara muka pada masa yang sama, dan antara muka adalah bebas antara satu sama lain dan tidak mengetahui pelaksanaan satu sama lain .

Dua program pada rangkaian bertukar data melalui sambungan komunikasi dua hala Satu hujung sambungan dipanggil Soket. Soket boleh membaca dan menulis data pada masa yang sama, ciri ini serupa dengan fail. Oleh itu, semasa pembangunan, ciri membaca dan menulis kedua-dua fail dan Soket disarikan ke dalam konsep pembaca dan penulis bebas.

Soket, seperti fail, juga perlu mengeluarkan sumber selepas digunakan.

Ciri-ciri Socket yang boleh menulis data dan perlu ditutup diterangkan menggunakan antara muka Sila rujuk kod berikut:

type Socket struct {
}
func (s *Socket) Write(p []byte) (n int, err error) {
    return 0, nil
}
func (s *Socket) Close() error {
    return nil
}

Kaedah Write() bagi struktur Soket yang dilaksanakan. antara muka io.Writer :

type Writer interface {
    Write(p []byte) (n int, err error)
}

Pada masa yang sama, struktur Socket juga melaksanakan antara muka io.Closer:

type Closer interface {
    Close() error
}

Menggunakan kod antara muka Writer yang dilaksanakan oleh Socket , tidak perlu mengetahui sama ada pelaksana antara muka Penulis mempunyai ciri Antara Muka Lebih Dekat. Begitu juga, kod yang menggunakan antara muka Closer tidak mengetahui bahawa Soket telah melaksanakan antara muka Penulis, seperti yang ditunjukkan dalam rajah berikut.

Rajah: Proses penggunaan dan pelaksanaan antara muka

Antara muka Writer dan kod antara muka Closer yang dilaksanakan menggunakan struktur Soket dalam kod adalah seperti berikut:

// 使用io.Writer的代码, 并不知道Socket和io.Closer的存在
func usingWriter( writer io.Writer){
    writer.Write( nil )
}
// 使用io.Closer, 并不知道Socket和io.Writer的存在
func usingCloser( closer io.Closer) {
    closer.Close()
}
func main() {
    // 实例化Socket
    s := new(Socket)
    usingWriter(s)
    usingCloser(s)
}

usingWriter() dan usingCloser() adalah bebas sepenuhnya Mereka tidak mengetahui kewujudan satu sama lain, dan mereka juga tidak tahu bahawa antara muka yang mereka gunakan dilaksanakan oleh Socket.

Berbilang jenis boleh melaksanakan antara muka yang sama

Kaedah antara muka tidak semestinya perlu dilaksanakan sepenuhnya oleh satu jenis Kaedah antara muka boleh dibenamkan dalam jenis lain dalam jenis atau struktur. Dalam erti kata lain, pengguna tidak peduli sama ada kaedah antara muka dilaksanakan sepenuhnya melalui satu jenis, atau sama ada ia dilaksanakan melalui berbilang struktur yang tertanam dalam struktur dan disatukan.

Antara muka Perkhidmatan mentakrifkan dua kaedah: satu adalah untuk memulakan perkhidmatan (Start()), dan satu lagi adalah untuk mengeluarkan log (Log()). Gunakan struktur GameService untuk melaksanakan struktur GameService sendiri hanya boleh melaksanakan kaedah Start() dan kaedah Log() dalam antara muka Perkhidmatan telah dilaksanakan oleh logger (Logger) yang boleh mengeluarkan log GameService. Atau laksanakannya semula. Oleh itu, memilih untuk membenamkan Logger ke dalam GameService boleh mengelakkan redundansi kod dan memudahkan struktur kod sepenuhnya. Proses pelaksanaan terperinci adalah seperti berikut:

// 一个服务需要满足能够开启和写日志的功能
type Service interface {
    Start()  // 开启服务
    Log(string)  // 日志输出
}
// 日志器
type Logger struct {
}
// 实现Service的Log()方法
func (g *Logger) Log(l string) {
}
// 游戏服务
type GameService struct {
    Logger  // 嵌入日志器
}
// 实现Service的Start()方法
func (g *GameService) Start() {
}

Penerangan kod adalah seperti berikut:

• Barisan 2 mentakrifkan antara muka perkhidmatan perlu melaksanakan Mula () kaedah dan kaedah pembalakan.

• Barisan 8 mentakrifkan struktur pembalak yang boleh mengeluarkan log.

• Baris 12, tambahkan kaedah Log() pada Logger dan laksanakan kaedah Log() Perkhidmatan.

• Barisan 17, mentakrifkan struktur GameService.

• Barisan 18, benamkan logger Logger dalam GameService untuk melaksanakan fungsi pengelogan.

• Barisan 22, kaedah Mula() GameService melaksanakan kaedah Mula() Perkhidmatan.

Pada ketika ini, nyatakan GameService dan tetapkan contoh kepada Perkhidmatan Kod adalah seperti berikut:

var s Service = new(GameService)
s.Start()
s.Log(“hello”)

s Anda boleh menggunakan kaedah Start() dan. Kaedah Log(), antaranya Start() dilaksanakan oleh GameService dan kaedah Log() dilaksanakan oleh Logger.

[Cadangan berkaitan: Pergi tutorial video, Pengajaran pengaturcaraan]

Atas ialah kandungan terperinci Apakah hubungan antara jenis dan antara muka dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!