reflect效率掉的太猛，这个是使用unsafe、interface与函数类型断言结合的方法来实现的，但是感觉不够优雅，看看后续想一想还有什么办法。

详细代码见下方，测试方法为test函数中的内容。

代码

package main

import "unsafe"

type Type1 func(int)

type Type2 func()

type IC interface {
	ret() unsafe.Pointer
	name() string
}

type TestA struct {
}

func (a *TestA) name() string {
	return "TestA"
}

func (a *TestA) test(i int) {
	println("TestA", i)
}

func (a *TestA) ret() unsafe.Pointer {
	reFn := a.test
	ptr := unsafe.Pointer(&reFn)
	return ptr
}

type TestB struct {
}

func (b *TestB) name() string {
	return "TestB"
}

func (b *TestB) test() {
	println("TestB")
}

func (b *TestB) ret() unsafe.Pointer {
	reFn := b.test
	ptr := unsafe.Pointer(&reFn)
	return ptr
}

func call(fn IC) {
	switch fn.name() {
	case "TestA":
		fnPtr := *(*Type1)(fn.ret())
		fnPtr(1)

	case "TestB":
		fnPtr := *(*Type2)(fn.ret())
		fnPtr()
	}
}

//go:noinline
func test() {

	a := &TestA{}
	b := &TestB{}

	call(a)
	call(b)

}

func main() {
	test()
}

输出内容：

TestA 1
TestB