est-il possible d'appeler une méthode de remplacement du parent struct dans Golang?

Comme vous l'avez écrit, ce qui va a n'est pas vraiment de l'héritage, la méthode qui permet à l'héritage comme caractéristiques est appelé Intégration.

http://golang.org/doc/effective_go.html#embedding

Ce que cela signifie essentiellement, c'est que l'embedded struct n'a aucune idée de qui il est intégré, donc vous ne pouvez pas remplacer tout ce qui est appelé à partir d'elle. Vous pouvez effectivement prendre l'embedded struct et prendre une référence pour seulement à partir de l'incorporation de struct.

Donc votre meilleure façon de le faire est plus ou moins comme votre deuxième exemple - par une sorte d'injection de dépendance à l'aide des interfaces. j'.e - Un a une référence à une interface qui fait tout le boulot, dire worker, qui écrit dans un fichier ou quoi que ce soit. Ensuite, lors de l'instanciation de B, vous pouvez également remplacer Un de worker avec un autre travailleur (vous pouvez le faire même sans l'incorporation d'Un bien sûr). L'A juste fait quelque chose comme myWorker.Work() sans se soucier de ce que travailleur il est.

Récemment j'ai besoin pour ce faire et la méthode de composition proposé par l'OP fonctionne très bien.

J'essaie de créer un autre exemple pour essayer de démontrer la relation parent-enfant et de le rendre plus facile à lire.

https://play.golang.org/p/9EmWhpyjHf:

package main

import (
    "fmt"
    "log"
)

type FruitType interface {
    Wash() FruitType
    Eat() string
}

type Fruit struct {
    name  string
    dirty bool
    fruit FruitType
}

func (f *Fruit) Wash() FruitType {
    f.dirty = false
    if f.fruit != nil {
        return f.fruit
    }
    return f
}
func (f *Fruit) Eat() string {
    if f.dirty {
        return fmt.Sprintf("The %s is dirty, wash it first!", f.name)
    }
    return fmt.Sprintf("%s is so delicious!", f.name)
}

type Orange struct {
    *Fruit
}

func NewOrange() *Orange {
    ft := &Orange{&Fruit{"Orange", true, nil}}
    ft.fruit = ft
    return ft
}
func NewApple() *Fruit {
    ft := &Fruit{"apple", true, nil}
    return ft
}

func (o *Orange) Eat() string {
    return "The orange is so sour!"
}

func main() {
    log.Println(NewApple().Eat())
    log.Println(NewApple().Wash().Eat())
    log.Println(NewOrange().Eat())
    log.Println(NewOrange().Wash().Eat())
}

Go ne prend pas en charge virtuel redéfinition de méthode. Le modèle de conception que vous souhaitez utiliser n'est donc pas directement pris en charge par Go. Il est considéré comme une mauvaise pratique car le changement de la mise en œuvre de A. de Bar() serait briser toutes les classes dérivées comme le B, qui assument A. Foo() sera appelée par A. de Bar(). Le modèle de conception que vous voulez utiliser de rendre votre code fragile.

La façon de le faire, il en serait de définir un Fooer l'interface avec les Foo() la méthode. Un Fooer serait passée comme argument à la Barre() ou stockées dans un champ de Un et appelé par A. de Bar(). Pour changer de Foo l'action, le changement de la Fooer valeur. Cela s'appelle de la composition, et c'est beaucoup mieux que de changer de Foo action par l'héritage et redéfinition de méthode.

Voici un idiomatiques moyen de faire ce que vous voulez faire dans le jeu de Go: https://play.golang.org/p/jJqXqmNUEHn. Dans cette implémentation, la Fooer est un champ de membre d'Un qui est initialisé par un paramètre de l'exemple de l'usine de la fonction NewA(). Ce modèle de conception est préférable lorsque les Fooer ne change pas fréquemment au cours de la durée de vie de A. dans le cas Contraire, vous pouvez passer le Fooer comme paramètre de la Bar() méthode.

C'est comment nous avons changé le comportement de Foo() en Aller. Il est appelé composition parce que vous modifiez le comportement de Bar() en changeant le cas de la composition A.

package main

import (
    "fmt"
)

type Fooer interface {
    Foo()
}

type A struct {
    f Fooer
}

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

func NewA(f Fooer) *A {
    return &A{f: f}
}

type B struct {
}

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

type C struct {
}

func (c *C) Foo() {
    fmt.Println("C.Foo()")
}

func main() {
    a := NewA(new(B))
    a.Bar()

    a.f = &C{}
    a.Bar()
}

PS: Ici est possible de mise en oeuvre du modèle de conception que vous vouliez mettre en œuvre pour but de la documentation: https://play.golang.org/p/HugjIbYbout