Go 实现多态和 参数的动态个数及动态类型

引子

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作为 定义一个类型的接口,只要实现了其中定义的所有方法,那么就实现了这个类型的接口;以此为基础 实现 多态功能,此功能 较为实用及重要;