Rumah  >  Artikel  >  pembangunan bahagian belakang  >  Mengapakah Go membuang ralat apabila pelaksanaan jenis konkrit mengembalikan jenis konkrit dan bukannya jenis antara muka yang dijangkakan dalam kaedah antara muka?

Mengapakah Go membuang ralat apabila pelaksanaan jenis konkrit mengembalikan jenis konkrit dan bukannya jenis antara muka yang dijangkakan dalam kaedah antara muka?

DDD
DDDasal
2024-10-30 07:33:02187semak imbas

Why does Go throw an error when a concrete type implementation returns a concrete type instead of the expected interface type in an interface method?

Kaedah Antara Muka Mengembalikan Ketidakpadanan Antara Muka dengan Pelaksanaan Jenis Konkrit

Apabila bekerja dengan antara muka Go, ralat boleh berlaku apabila kaedah antara muka yang mengisytiharkan jenis antara muka pemulangan dilaksanakan mengikut jenis konkrit. Ralat ini timbul kerana pelaksanaan kaedah tidak secara langsung mengembalikan jenis antara muka tetapi sebaliknya mengembalikan jenis konkrit yang melaksanakan antara muka.

Pertimbangkan contoh berikut:

<code class="go">package main

import "fmt"

type Foo struct {
    val string
}

func (f *Foo) String() string {
    return f.val
}

type StringerGetter interface {
    GetStringer() fmt.Stringer
}

type Bar struct{}

func (b *Bar) GetStringer() *Foo {
    return &Foo{"foo"}
}

func Printer(s StringerGetter) {
    fmt.Println(s.GetStringer())
}

func main() {
    f := Bar{}
    Printer(&f)
}</code>

Di sini, Fungsi pencetak mengharapkan antara muka StringerGetter, yang mempunyai kaedah GetStringer yang mengembalikan fmt.Stringer, manakala kaedah GetStringer jenis Bar mengembalikan Foo jenis konkrit yang melaksanakan antara muka fmt.Stringer. Ini menyebabkan ralat:

prog.go:29: cannot use &f (type *Bar) as type StringerGetter in
argument to Printer: *Bar does not implement StringerGetter (wrong
type for GetStringer method) had GetStringer() *Foo want
GetStringer() fmt.Stringer

Penyelesaian kepada isu ini terletak pada menjadikan kaedah antara muka sepadan dengan jenis antara muka yang dijangkakan. Dalam kes ini, kaedah GetStringer harus mengembalikan fmt.Stringer dan bukannya jenis konkrit:

<code class="go">func (b *Bar) GetStringer() fmt.Stringer {
    return &Foo{"foo"}
}</code>

Sebagai alternatif, seseorang boleh mencipta jenis pembalut yang melaksanakan antara muka yang dikehendaki dan mewakilkan kepada jenis konkrit, seperti yang ditunjukkan dalam teknik berikut:

Taip Benamkan dengan Delegasi:

<code class="go">type MyBar struct{ Bar }

func (b *MyBar) GetStringer() fmt.Stringer {
    return b.Bar.GetStringer()
}</code>

Pembungkusan Jenis:

<code class="go">type MyBar Bar

func (b *MyBar) GetStringer() fmt.Stringer {
    return &Foo{"foo"}
}</code>

Teknik ini membenarkan antara muka yang lancar dengan jenis konkrit tanpa mengubah suainya secara langsung. Dengan membalut atau membenamkan jenis konkrit, jenis tersuai boleh dibuat yang mematuhi kontrak antara muka yang diingini.

Atas ialah kandungan terperinci Mengapakah Go membuang ralat apabila pelaksanaan jenis konkrit mengembalikan jenis konkrit dan bukannya jenis antara muka yang dijangkakan dalam kaedah antara muka?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Kenyataan:
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn