内嵌的结构体如何调用其外部结构体的方法？

我记得反射的情况下，如果是一个结构实现了一个接口，可以用强制转换成接口在调用接口方法

这样的想法下，你的Dog也要实现一个Escape才可能实现吧。。。

结构体的内嵌规则问题，因为Dog结构体，没有对应的Escape方法，所以这里的dog.Escape等效于dog.Animal.Excape方法

抱歉题主，请忽略这一条

编程中难免遇到这种情况，就是有些方法可以继承父类的，有些又需要重写。但是继承自父类的方法就不能调用重写之后的方法，不知道有没有什么好的解决方法。

package main

import (
    "fmt"
    "reflect"
)
type IAnimal interface {
    Run()
}
type Animal struct{}

func (a *Animal) Escape(ianimal IAnimal) {
    ianimal.Run()
}

func (a *Animal) Run() {
    fmt.Printf("Animal Run.\n")
}

type Dog struct {
    Animal
}

func (d *Dog) Run() {
    fmt.Printf("Dog Run.\n")
}

func main() {
    dog := &Dog{}
    dogv:=reflect.ValueOf(dog)
    dogt:=reflect.Indirect(dogv).Type()
    dognew:=reflect.New(dogt)
    dogi:=dognew.Interface().(IAnimal)
    dog.Escape(dogi)
}

package main

import (

    "fmt"
    "reflect"

)

type IAnimal interface {

    Run()

}

type Animal struct{}


func (a *Animal) Escape(ianimal IAnimal) {

    ianimal.Run()
}


func (a *Animal) Run() {

    fmt.Printf("Animal Run.\n")

}


type Dog struct {

    Animal
}


func (d *Dog) Run() {

    fmt.Printf("Dog Run.\n")
}

func main() {

dog := &Dog{}
dogv:=reflect.ValueOf(dog)
dogt:=reflect.Indirect(dogv).Type()
dognew:=reflect.New(dogt)
dogi:=dognew.Interface().(IAnimal)
dog.Escape(dogi)

}

package main

import  "fmt"

type IAnimal interface {

    Run()

}
type Animal struct{}

func (a *Animal) Escape(ianimal IAnimal) {

    ianimal.Run()

}

func (a *Animal) Run() {

    fmt.Printf("Animal Run.\n")
}

type Dog struct {

    s Animal
}

func (d *Dog) Run() {

    fmt.Printf("Dog Run.\n")
}

func main() {

    dog := &Dog{}
    dog.s.Escape(dog)
    ad:=&Animal{}
    ad.Escape(ad)

}

//输出
//Dog Run.
//Animal Run.

ad.Escape(ad)，调用自己的方法的时候，还要传入自己，感觉怪怪的。

package main

import  "fmt"

type IAnimal interface {

    Run()

}
type Animal struct{}

func (a *Animal) Escape() {

    a.Run()

}

func (a *Animal) Run() {

    fmt.Printf("Animal Run.\n")
}

type Dog struct {

     Animal
}

func (d *Dog) Run() {

    fmt.Printf("Dog Run.\n")
}

func main() {

    dog := &Dog{}
    dog.Run()
    dog.Animal.Escape()

}

go的采用组合的方式来实现继承。

package main

import (
    "fmt"
)

type IAnimal interface {
    Run()
    Escape()
}
type Animal struct{
    Name string
}

func NewAnimal() IAnimal{
    return &Animal{"Animal"}
}

func (a *Animal) Escape() {
    a.Run()
}

func (a *Animal) Run() {

    fmt.Printf("%s Run.\n", a.Name)
}

type Dog struct {
    Animal
}

func NewDog() IAnimal{
    d := &Dog{}
    d.Name = "Dog"
    return d
}


func main() {
    dog := NewDog()
    dog.Run()
    dog.Escape()

}