Chcę zaimplementować taki kod, w którym B dziedziczy z A i tylko nadpisuje metodę Foo () A i mam nadzieję, że kod wydrukuje B.Foo (), ale nadal drukuje A.Foo (), wydaje się, że odbiornik w Golang nie działa tak w C ++, w którym po włączeniu wiązania dynamicznego kod może działać tak, jak chcę.

Zamieszczam też kolejny fragment kodu, który działa, ale jest zbyt trudny do wdrożenia i bardziej przypomina sposób hackowania, myślę, że nie jest to styl Golang.

Więc moim problemem jest: jeśli metoda Bar () rodzica ma jakąś logikę, na przykład, otwórz plik, a następnie przeczytaj kilka wierszy i użyj Foo (), aby wyprowadzić te linie na standardowe wyjście, a Dziecko (w tym przykładzie to B) chce korzystać z większości z nich, jedyną różnicą jest to, że Dziecko chce, aby Foo () wysyłało linie do innego pliku. Jak mam to wdrożyć? Słyszałem, że dziedziczenie Golanga nie działa tak jak C ++ czy Java, a co słusznie w Golang?

package main 

import ( 
        "fmt" 
) 

type A struct { 
} 

func (a *A) Foo() { 
        fmt.Println("A.Foo()") 
} 

func (a *A) Bar() { 
        a.Foo() 
} 

type B struct { 
        A 
} 

func (b *B) Foo() { 
        fmt.Println("B.Foo()") 
} 

func main() { 
        b := B{A: A{}} 
        b.Bar() 
}

output: A.Foo()

następny utwór działa, ale kiedy piszę

a := A{}
a.Bar()

napotkasz błąd kompilatora

package main

import (
    "fmt"
)

type I interface {
    Foo()
}

type A struct {
    i I

}

func (a *A) Foo() {
    fmt.Println("A.Foo()")
}

func (a *A) Bar() {
    a.i.Foo()

}

type B struct {
    A
}

func (b *B) Foo() {
    fmt.Println("B.Foo()")
}

func main() {
    b := B{A: A{}}
    b.i = &b     // here i works like an attribute of b
    b.Bar()

output: B.Foo()