引子

go语言作为静态(编译期类型检测)强类型(手写代码进行类型转换)语言, 要想实现 动态语言的鸭子类型的调用方法,做到 一个入参是不同类型,还是有些麻烦的;

需求

• 希望写代码时像python一样的鸭子类型,不用管参数类型,都可以调用同一个方法;
• 希望 入参像python一样 能够在 个数上动态变化及类型上也动态变化;

go语言实现如上需求需要的技术

interface实现

• interface作为 定义一个类型的接口 实现 多态,只要 具体的结构体实现了 此接口中定义的方法,编译器就会进行隐式的类型转换,从而实现多态;
• interface作为 函数参数 实现 动态的参数类型;

多态定义

• 面向对象3大特性之一
• 指 一类事务有多种形态,如 动物类 具体有 猫,狗,猪等, 他们都会"走路", 当我们调用 “走路” 方法时,不用考虑具体是什么动物,只用调用即可;

代码实现

// Package main
// @Description: 所谓interface(接口)  类似python中的 多个对象 都有一个相同的方法;  将 多个对象根据条件 灵活的复制给一个变量,此变量可以调用这个方法;
//
//	接口 是一种动态类型, 才可以实现 多个结构体 赋值给一个变量;
//	接口 里实现的相关方法,可以是指针接收者实现 或者 值接收者实现;不同点在于 在接口中 值接收者 可以接收值和指针2种方式;而 指针接收者 只能接收 指针类型; 所有写代码时 最好写 值接收者;
//	接口就像一个协议,要想调用此接口的 结构体必须实现 接口里要求的方法才行;
package mainimport ("errors""fmt""math/rand""reflect"
)// FinanceCal
// @Description: 定义一个接口, 里面实现了2个方法; 要想调用此接口,则 调用方 必须实现接口里的2个方法
type FinanceCal interface {//// QuerySQL//  @Description: 动态类型的动态入参个数的 方法(基本就是动态语言的特点了)//  @param ...interface{}//  @return string//QuerySQL(...interface{}) string//// buy//  @Description:一个普通未带参数的方法//buy()////  sell//  @Description: 带参数的 方法(静态语言的一般方法)//  @param amount:卖出金额//sell(amount int)
}// FinanceQuerySql
//
//	@Description: 鸭子类型的多态,只要实现了此接口下的所有方法的结构体 都可以调用此方法
//	@param obj:
//	@param params:
//	@return string:
func FinanceQuerySql(obj FinanceCal, params ...interface{}) string {return obj.QuerySQL(params...)
}// Fund
// @Description: 基金结构体
type Fund struct {////  name//  @Description://name string
}// QuerySQL
//
//	@Description:生成查询sql
//	@receiver f:
//	@param params: 动态入参,入参个数为1个或0个;参数类型 是int类型
//	@return string:
func (f Fund) QuerySQL(params ...interface{}) string {//参数处理部分//参数长度校验//第一个参数处理l := len(params)if l > 1 {panic(errors.New("入参个数错误,应该<=1个参数"))}var num interface{}if l == 1 {paramNum := params[0]t := reflect.ValueOf(paramNum)if t.Kind() != reflect.Int {panic(errors.New("数据类型错误,应该是Int类型"))}num = paramNum.(int)}//业务处理部分sql := fmt.Sprintf("select * from fund where name in \"%v\"", f.name)if num != nil {sql += fmt.Sprintf(" and num=%v", num)}fmt.Println("fund sql查询语句为:", sql)return sql
}// buy
//
//	@Description: 购买基金
//	@receiver f:
func (f Fund) buy() {fmt.Printf("基金 %s 购买\n", f.name)
}// sell
//
//  @Description:
//  @receiver f:
//  @param amount:
func (f Fund) sell(amount int) {fmt.Printf("基金 %s 卖出 %d 元\n", f.name, amount)
}// Stock
// @Description: 股票结构体
type Stock struct {////  name//  @Description://name string
}// QuerySQL
//
//	@Description:生成查询sql
//	@receiver f:
//	@param params: 动态入参,入参个数为 0~2个;第一个参数 是int类型;第二个参数是 string类型;
//	@return string:
func (f Stock) QuerySQL(params ...interface{}) string {//参数处理部分//参数长度校验l := len(params)if l > 2 {panic(errors.New("入参个数错误,应该<=2个参数"))}//第一个参数处理var num interface{}if l >= 1 {paramNum := params[0]t := reflect.ValueOf(paramNum)if t.Kind() != reflect.Int {panic(errors.New("第一个参数 数据类型错误,应该是Int类型"))}num = paramNum.(int)}var manager interface{}if l == 2 {paramString := params[1]t := reflect.ValueOf(paramString)if t.Kind() != reflect.String {panic(errors.New("第二个参数 数据类型错误,应该是String类型"))}manager = paramString.(string)}//业务处理部分sql := fmt.Sprintf("select * from stock where name in \"%v\"", f.name)if num != nil {sql += fmt.Sprintf(" and num=%v", num)}if manager != nil {sql += fmt.Sprintf(" and manager=\"%v\"", manager)}fmt.Println("stock sql查询语句为:", sql)return sql
}// buy
//
//	@Description: 购买股票
//	@receiver f:
func (f Stock) buy() {fmt.Printf("股票 %s 购买\n", f.name)
}// sell
//
//  @Description:
//  @receiver f:
//  @param amount:
func (f Stock) sell(amount int) {fmt.Printf("股票 %s 卖出 %d 元\n", f.name, amount)
}func main() {//此方法一般是判断 结构体是否实现了 接口的方法,没实现 则直接编译时报错var _ FinanceCal = Fund{}var _ FinanceCal = (*Stock)(nil)//  定义 结构体 的变量,并实例化fund := Fund{"00001.OF"}//  定义一个 接口类型的变量 如下2种方法//var f = FinanceCal(fund)var fc FinanceCal = fund//  将 结构体 变量赋值给 接口类型变量//  fund的值赋值给fcfc = fund//  接口类型变量 调用对应的方法fc.buy()fc.QuerySQL(1)fc.QuerySQL()fc.sell(100)//  stock的指针赋值给fcstock := Stock{"023123.SZ"}fc = stock//  接口类型变量 调用对应的方法, 也就是 类似python中,无论 哪个对象赋值给此变量,都可以访问 这些对象有的某个方法fc.QuerySQL()fc.QuerySQL(1)fc.QuerySQL(1, "经理")fc.buy()fc.sell(1000)// 鸭子类型的实现var obj FinanceCalvar params []interface{}if rand.Intn(10)%2 == 0 {obj = fundparams = []interface{}{666}fmt.Println("对象是Fund结构体的示例")} else {obj = stockparams = []interface{}{345, "经理A"}fmt.Println("对象是Stock结构体的示例")}FinanceQuerySql(obj, params...)
}

执行结果

总结

• go语言中 函数参数或变量类型里的interface(如 : func add(input interface{})) 实现了 不同类型的值 赋值的功能,实现了动态类型语言的灵活性;
• go语言中 对变量初始化为interface{}类型,实现了 业务代码中经常需要判断 参数是否有值的功能,因为 go语言定义为具体类型,都会有默认值,如 int类型默认值为0,而实际业务中0也可能是有效数据,无法作为是否有值的判断;

// go代码 判断值是否为空
var num =interface{}
if num==nil{print("num没有值")
}
num=1
print("num被赋值为int类型的值为1")

# python代码判断值是否为空
num=None
if num==None:print("num没有值")

• go语言中的interface作为 定义一个类型的接口,只要实现了其中定义的所有方法,那么就实现了这个类型的接口;以此为基础 实现 多态功能,此功能 较为实用及重要;