引子
go语言作为静态(编译期类型检测)强类型(手写代码进行类型转换)语言, 要想实现 动态语言的鸭子类型的调用方法,做到 一个入参是不同类型,还是有些麻烦的;
需求
- 希望写代码时像python一样的鸭子类型,不用管参数类型,都可以调用同一个方法;
- 希望 入参像python一样 能够在 个数上动态变化及类型上也动态变化;
go语言实现如上需求需要的技术
interface实现
- interface作为 定义一个类型的接口 实现 多态,只要 具体的结构体实现了 此接口中定义的方法,编译器就会进行隐式的类型转换,从而实现多态;
- interface作为 函数参数 实现 动态的参数类型;
多态定义
- 面向对象3大特性之一
- 指 一类事务有多种形态,如 动物类 具体有 猫,狗,猪等, 他们都会"走路", 当我们调用 “走路” 方法时,不用考虑具体是什么动物,只用调用即可;
代码实现
// Package main
// @Description: 所谓interface(接口) 类似python中的 多个对象 都有一个相同的方法; 将 多个对象根据条件 灵活的复制给一个变量,此变量可以调用这个方法;
//
// 接口 是一种动态类型, 才可以实现 多个结构体 赋值给一个变量;
// 接口 里实现的相关方法,可以是指针接收者实现 或者 值接收者实现;不同点在于 在接口中 值接收者 可以接收值和指针2种方式;而 指针接收者 只能接收 指针类型; 所有写代码时 最好写 值接收者;
// 接口就像一个协议,要想调用此接口的 结构体必须实现 接口里要求的方法才行;
package main
import (
"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的值赋值给fc
fc = fund
// 接口类型变量 调用对应的方法
fc.buy()
fc.QuerySQL(1)
fc.QuerySQL()
fc.sell(100)
// stock的指针赋值给fc
stock := Stock{"023123.SZ"}
fc = stock
// 接口类型变量 调用对应的方法, 也就是 类似python中,无论 哪个对象赋值给此变量,都可以访问 这些对象有的某个方法
fc.QuerySQL()
fc.QuerySQL(1)
fc.QuerySQL(1, "经理")
fc.buy()
fc.sell(1000)
// 鸭子类型的实现
var obj FinanceCal
var params []interface{}
if rand.Intn(10)%2 == 0 {
obj = fund
params = []interface{}{666}
fmt.Println("对象是Fund结构体的示例")
} else {
obj = stock
params = []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作为 定义一个类型的接口,只要实现了其中定义的所有方法,那么就实现了这个类型的接口;以此为基础 实现 多态功能,此功能 较为实用及重要;
