今天给大家说一说关于go语言方法重载的方法，具体如下：

    首先认清重载函数的定义

    1. 1：函数参数个数不同
    3. 2：函数参数类型不同，或者类型顺序不同
    5. Go语言本身不支持函数的重载，所以，我们利用反射+switch进行模拟反射，动态进行函数调用。

    根据函数参数的个数不同，实现函数重载

    首先声明结构体，并绑定两个参数

    1. type Students struct {
    3. Name string `json:"name"`
    5. Age int
    7. }
    9. func (stu Students)T(n1 int,n2 int)int{//方法需要传递两个参数
    11. return n1+n2
    13. }
    15. func (stu Students)R(n1 int)int{//方法需要传递一个参数
    17. return n1
    19. }

    实现动态调用方法的函数

    1. func reflecttest(n interface{},n2 ...interface{})(int,error){
    2.     v:=reflect.ValueOf(n)
    3.     switch len(n2) {
    4.         case 1://如果传参为一个值
    5.             params:=make([]reflect.Value,1)
    6.             params[0]=reflect.ValueOf(n2[0])//注意传参时，需要将值的类型转化为value类型
    7.             return int(v.MethodByName("R").Call(params)[0].Int()),nil//注意，返回的值以数组形式进行返回，再将返回的值转化为int64，再强制转化为int型数据
    8.         case 2:如果参数为两个
    9.             params:=make([]reflect.Value,2)
    10.             for k,v1:=range n2{ 
    11.                 params[k]=reflect.ValueOf(v1) 
    12.             }   
    13.             return int(v.MethodByName("T").Call(params)[0].Int()),nil
    14.         default://如果传参的数量不是一个或两个。    
    15.             err:=errors.New("调用函数不存在")
    16.         return 0,err//返回错误
    18.     }
    20. }
    1. 根据函数参数类型的不同，调用不同的函数
    3. 结构体及其绑定的方法
    5. type Students struct {
    7.     Name string `json:"name"`
    9.     Age int
    11. }
    13. func (stu Students)T(n1 int,n2 int)string{
    15.     return n1+"T()"+strconv.Itoa(n2)
    17. }
    19. func (stu Students)R(n1 int,n2 string)string{
    21.     return strconv.Itoa(n1)+"R()"+n2
    23. }
    25. func reflecttest(n interface{},n2 ...interface{})(string,error){
    27.     v:=reflect.ValueOf(n)
    29.     if len(n2)!=2{//如果参数个数不为2，返回错误
    31.         err:=errors.New("参数个数错误")
    33.         return "",err
    35.     }
    37.     if reflect.TypeOf(n2[0]).String()!="int"{//如果第一个数据类型不为int型，返回错误
    39.         err:=errors.New("参数类型错误")
    41.         return "",err
    43.     }
    45.     switch  n2[1].(type){//针对第二个参数的参数类型，进行讨论
    47.         case string://如果为string
    49.         params:=make([]reflect.Value,2)
    51.         for k,v1:=range n2 {
    53.         params[k]=reflect.ValueOf(v1)
    55.     }
    57.         return v.MethodByName("R").Call(params)[0].String(),nil
    59.         case int://如果为int
    61.         params:=make([]reflect.Value,2)
    63.         for k,v1:=range n2{
    65.         params[k]=reflect.ValueOf(v1)
    67.     }
    69.         return v.MethodByName("T").Call(params)[0].String(),nil
    71.         default://如果不为string或int
    73.         err:=errors.New("未找到相应函数")
    75.         return "",err
    77.     }
    79. }
    1. 类型顺序不同，调用不同函数
    3. 结构体及其绑定的方法
    5. type Students struct {
    7.     Name string `json:"name"`
    9.     Age int
    11. }
    13. func (stu Students)T(n1 string,n2 int)string{
    15.     return n1+"T()"+strconv.Itoa(n2)
    17. }
    19. func (stu Students)R(n1 int,n2 string)string{
    21.     return strconv.Itoa(n1)+"R()"+n2
    23. }
    25. func reflecttest(n interface{},n2 ...interface{})(string,error){
    27.     if len(n2)!=2{//判断参数是否为2个
    29.         err:=errors.New("参数个数不正确")
    31.         return "",err
    33.     }
    35.     v:=reflect.ValueOf(n)
    37.     params:=make([]reflect.Value,2)
    39.     switch n2[0].(type) {
    41.         case string://判断第一个参数的类型
    43.         if reflect.TypeOf(n2[1]).String()=="int"{//判断第二个参数的类型
    45.         for k,v1:=range n2{
    47.         params[k]=reflect.ValueOf(v1)
    49.     }
    51.         return v.MethodByName("T").Call(params)[0].String(),nil
    53.     }else{
    55.         err:=errors.New("由于第二个参数类型错误，未能找到函数")
    57.         return "",err
    59.     }
    61.         case int://判断第一个参数类型
    63.         if reflect.TypeOf(n2[1]).String()=="string"{//判断第二个参数类型
    65.         for k,v1:=range n2{
    67.         params[k]=reflect.ValueOf(v1)
    69.     }
    71.         return v.MethodByName("R").Call(params)[0].String(),nil
    73.     }else{
    75.         err:=errors.New("第二个参数类型错误，函数调用失败")
    77.         return "",err
    79.     }
    81.         default:
    83.         err:=errors.New("第一个参数类型错误，函数调用失败")
    85.         return "",err
    87.     }
    89. }