Bagaimana untuk Mencapai Fungsi Mengatasi Kaedah dalam Go?

Kaedah Overriding dalam Go

Dalam Go, tiada persamaan langsung dengan kaedah overriding seperti yang terdapat dalam bahasa berorientasikan objek seperti Java. Walau bagaimanapun, terdapat pendekatan alternatif untuk mencapai kefungsian yang sama.

Pertimbangkan senario di mana anda mempunyai jenis asas Base dengan kaedah Get() yang mengembalikan rentetan "base". Anda ingin menentukan Sub jenis baharu yang mewarisi daripada Base tetapi mempunyai pelaksanaan Get() berbeza yang mengembalikan "Sub".

Percubaan awal anda menggunakan komposisi seperti itu:

type Sub struct {
    Base
}

func(sub *Sub) Get() string {
    return "Sub"
}

tidak akan berfungsi kerana kaedah Get() Sub tidak boleh mengatasi kaedah Get() Base. Ini disebabkan oleh semantik penerima kaedah Go, di mana jenis penerima (dalam kes ini *Base) menentukan kaedah yang akan dipanggil.

Menggunakan Antara Muka

Satu pendekatan alternatif ialah menggunakan antara muka. Antara muka mentakrifkan kontrak kaedah yang mesti dilaksanakan oleh jenis, serupa dengan kelas abstrak Java. Dalam kes ini, anda boleh mentakrifkan antara muka Getter dengan kaedah Get() tunggal.

type Getter interface {
    Get() string
}

Anda kemudian boleh mengubah suai Base untuk melaksanakan antara muka Getter:

type Base struct {
}

func (base *Base) Get() string {
    return "base"
}

Sekarang, anda boleh mentakrifkan Sub sebagai struct yang membenamkan contoh Base dan juga melaksanakan Getter:

type Sub struct {
    Base
}

func (sub *Sub) Get() string {
    return "Sub"
}

Anda kemudian boleh menggunakan Kaedah GetName() untuk menentukan secara dinamik pelaksanaan Get() yang hendak dipanggil:

func (base *Base) GetName(getter Getter) string {
    if g, ok := getter.(Getter); ok {
        return g.Get()
    } else {
        return base.Get()
    }
}

Dalam fungsi utama, anda boleh mencipta contoh Sub, menghantarnya ke Getter, dan kemudian menyerahkannya kepada GetName( ):

userType := Sub{}
fmt.Println(userType.GetName()) // prints "Sub"

Pembenaman Kaedah

Alternatif lain ialah menggunakan kaedah pembenaman. Ini membolehkan anda menambah kaedah pada struct dengan membenamkan jenis yang melaksanakan kaedah tersebut. Dalam kes ini, anda boleh mentakrifkan jenis baharu SubGetter yang membenamkan Base dan melaksanakan kaedah Get() baharu:

type SubGetter struct {
    Base
}

func (sub *SubGetter) Get() string {
    return "Sub"
}

Anda kemudiannya boleh menggunakan SubGetter sebagai kaedah Base:

type Base struct {
    SubGetter
}

Ini membolehkan anda memanggil kaedah Get() SubGetter seolah-olah ia adalah kaedah Base:

base := Base{}
fmt.Println(base.Get()) // prints "Sub"

Atas ialah kandungan terperinci Bagaimana untuk Mencapai Fungsi Mengatasi Kaedah dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!