Go语言中利用接口和嵌入式结构实现多态的通用函数设计

package main

import (
    "fmt"
    "reflect"
)

type Animal struct {
    Type string
}

type Dog struct {
    Animal // 嵌入 Animal
}

type Cat struct {
    Animal // 嵌入 Animal
}

func (d *Dog) SayWoof() {
    fmt.Println("WOOF")
}

func (c *Cat) SayMeow() {
    fmt.Println("MEOUW")
}

// 初始的通用函数尝试：通过反射和多参数传递
func CallMethodReflect(animal interface{}, baseAnimal *Animal, methodName string) {
    fmt.Println("Animal type: ", baseAnimal.Type) // 访问嵌入的 Animal 字段

    method := reflect.ValueOf(animal).MethodByName(methodName)
    if !method.IsValid() {
        fmt.Printf("Method %s not found for type %T\n", methodName, animal)
        return
    }
    method.Call([]reflect.Value{}) // 动态调用方法
}

func main() {
    dog := &Dog{}
    dog.Type = "Dog" // 直接访问嵌入的 Animal 字段

    cat := &Cat{}
    cat.Type = "Cat"

    // 调用时需要传递两次对象，并指定方法名
    CallMethodReflect(dog, &dog.Animal, "SayWoof")
    CallMethodReflect(cat, &cat.Animal, "SayMeow")
}

Animal type:  Dog
WOOF
Animal type:  Cat
MEOUW

package main

import "fmt"

// 定义一个接口，包含动物的共同行为和属性访问方法
type Animal interface {
    Speak()        // 共同的叫声行为
    GetType() string // 共同的获取类型属性的方法
}

// 嵌入式基础结构体，用于共享数据
type BaseAnimal struct {
    Type string
}

// Dog 结构体，嵌入 BaseAnimal 并实现 Animal 接口
type Dog struct {
    BaseAnimal // 嵌入 BaseAnimal
}

// Dog 实现 Animal 接口的 Speak 方法
func (d *Dog) Speak() {
    fmt.Println("Woof")
}

// Dog 实现 Animal 接口的 GetType 方法
func (d *Dog) GetType() string {
    return d.Type
}

// Cat 结构体，嵌入 BaseAnimal 并实现 Animal 接口
type Cat struct {
    BaseAnimal // 嵌入 BaseAnimal
}

// Cat 实现 Animal 接口的 Speak 方法
func (c *Cat) Speak() {
    fmt.Println("Meow")
}

// Cat 实现 Animal 接口的 GetType 方法
func (c *Cat) GetType() string {
    return c.Type
}

// 通用函数，只接受 Animal 接口作为参数
func ProcessAnimal(a Animal) {
    fmt.Printf("Processing animal of type: %s\n", a.GetType()) // 通过接口方法访问类型
    a.Speak()                                                 // 通过接口方法调用叫声
}

func main() {
    // 初始化 Dog 和 Cat 对象，并设置 BaseAnimal 字段
    dog := &Dog{BaseAnimal: BaseAnimal{Type: "Dog"}}
    cat := &Cat{BaseAnimal: BaseAnimal{Type: "Cat"}}

    // 调用通用函数，只需传递一次对象
    ProcessAnimal(dog)
    ProcessAnimal(cat)
}

Processing animal of type: Dog
Woof
Processing animal of type: Cat
Meow