Ich möchte einen solchen Code implementieren, bei dem B von A erbt und nur die Foo () -Methode von A überschreibt, und ich hoffe, dass der Code B.Foo () ausgibt, aber weiterhin A.Foo () ausgibt Golang kann in C ++ nicht so funktionieren. Wenn die dynamische Bindung aktiviert ist, kann der Code so funktionieren, wie ich es möchte.

Ich poste auch einen anderen Code, der funktioniert, aber zu schwer zu implementieren ist, und eher wie ein Hack, ich denke, es ist kein Golang-Stil.

Mein Problem ist also: Wenn die Bar () -Methode des übergeordneten Elements eine Logik hat, öffnen Sie beispielsweise eine Datei, lesen Sie einige Zeilen und geben Sie diese Zeilen mit Foo () an stdout aus, und das untergeordnete Element (im Beispiel ist B). Wenn Sie die meisten von ihnen verwenden möchten, besteht der einzige Unterschied darin, dass das Kind möchte, dass Foo () die Zeilen in eine andere Datei ausgibt. Wie soll ich es implementieren? Ich habe gehört, dass die Vererbung von Golang nicht wie C ++ oder Java funktionieren kann, und wie ist der richtige Weg in 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()

das folgende stück funktioniert aber beim schreiben

a := A{}
a.Bar()

Sie werden auf einen Compilerfehler stoßen

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()