Go 结构体中动态方法调用的实现：函数类型与切片

package main

import "fmt"

// 定义一个函数类型 FF，它接收一个 *Foo 类型的指针作为参数，没有返回值。
type FF func(*Foo)

// Foo 结构体，包含一个 FF 类型的函数字段
type Foo struct {
    fooFunc FF    // 结构体字段 fooFunc 的类型是 FF
    name    string
    age     int
}

// 示例函数 foo1，符合 FF 的签名
func foo1(f *Foo) {
    fmt.Println("[foo1] Name:", f.name)
}

// 示例函数 foo2，符合 FF 的签名
func foo2(f *Foo) {
    fmt.Println("[foo2] My name is ", f.name, " and my age is ", f.age)
}

func main() {
    // 创建 Foo 实例并赋值 fooFunc
    fooObject := Foo{
        name: "micheal",
    }
    fooObject.fooFunc = foo1 // 将 foo1 函数赋值给 fooFunc 字段

    // 调用存储的函数，并传入 fooObject 的指针
    fooObject.fooFunc(&fooObject)

    // 改变 fooObject 的状态并重新赋值 fooFunc
    fooObject = Foo{
        name: "lisa",
        age:  22,
    }
    fooObject.fooFunc = foo2 // 将 foo2 函数赋值给 fooFunc 字段

    // 再次调用
    fooObject.fooFunc(&fooObject)
}

package main

import "fmt"

// 定义一个函数类型 BB，它接收一个 *Bar 类型的指针作为参数，没有返回值。
type BB func(*Bar)

// Bar 结构体，包含一个 BB 类型的函数切片字段
type Bar struct {
    barFuncs []BB // 结构体字段 barFuncs 的类型是 BB 类型的切片
    salary   int
    debt     int
}

// 示例函数 barSalary，符合 BB 的签名
func barSalary(b *Bar) {
    fmt.Println("[barSalary] My salary is ", b.salary)
}

// 示例函数 barDebt，符合 BB 的签名
func barDebt(b *Bar) {
    fmt.Println("[barDebt] My debt is ", b.debt)
}

func main() {
    // 创建一个 BB 类型的函数切片
    barFuncList := make([]BB, 2) // 创建一个长度为2的切片
    barFuncList[0] = barSalary   // 赋值第一个函数
    barFuncList[1] = barDebt     // 赋值第二个函数

    // 创建 Bar 实例并赋值 barFuncs
    barObject := Bar{
        salary:   45000,
        debt:     200,
        barFuncs: barFuncList, // 将函数切片赋值给 barFuncs 字段
    }

    // 遍历函数切片并依次调用，传入 barObject 的指针
    for i := 0; i < len(barObject.barFuncs); i++ {
        barObject.barFuncs[i](&barObject)
    }
}

package main

import (
    "fmt"
)

// 定义 Foo 结构体及其相关函数类型和函数
type FF func(*Foo)

type Foo struct {
    fooFunc FF
    name    string
    age     int
}

func foo1(f *Foo) {
    fmt.Println("[foo1] Name:", f.name)
}

func foo2(f *Foo) {
    fmt.Println("[foo2] My name is ", f.name, " and my age is ", f.age)
}

// 定义 Bar 结构体及其相关函数类型和函数
type BB func(*Bar)

type Bar struct {
    barFuncs []BB
    salary   int
    debt     int
}

func barSalary(b *Bar) {
    fmt.Println("[barSalary] My salary is ", b.salary)
}

func barDebt(b *Bar) {
    fmt.Println("[barDebt] My debt is ", b.debt)
}

func main() {
    // Foo 结构体示例
    fooObject := Foo{
        name: "micheal",
    }
    fooObject.fooFunc = foo1
    fooObject.fooFunc(&fooObject) // 调用 foo1

    fooObject = Foo{
        name: "lisa",
        age:  22,
    }
    fooObject.fooFunc = foo2
    fooObject.fooFunc(&fooObject) // 调用 foo2

    fmt.Println("---")

    // Bar 结构体示例
    barFuncList := make([]BB, 2)
    barFuncList[0] = barSalary
    barFuncList[1] = barDebt

    barObject := Bar{
        salary:   45000,
        debt:     200,
        barFuncs: barFuncList,
    }

    for i := 0; i < len(barObject.barFuncs); i++ {
        barObject.barFuncs[i](&barObject) // 依次调用 barSalary 和 barDebt
    }
}

[foo1] Name: micheal
[foo2] My name is  lisa  and my age is  22
---
[barSalary] My salary is  45000
[barDebt] My debt is  200