文章目录
- 1、反射
- 2、对基本数据类型反射
- 3、对结构体进行反射
- 4、获取变量的类别
- 5、通过反射修改基本类型变量的值
- 6、通过反射操作结构体的属性和方法
1、反射
//核心包
import ("reflect")
通过反射:
- 可以在运行时动态获取变量的类型、获取结构体的信息(字段、方法)
- 可以修改变量的值,调用关联的方法
相关函数:
//作用:反射获取变量的类型
//返回类型是reflect.Type类型
reflect.TypeOf(变量名)
//作用:反射获取变量的值
//返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value,可以获取到关于该变量的很多信息
reflect.ValueOf(变量名)
2、对基本数据类型反射
空接口没有任何方法,所以可以理解为所有类型都实现了空接口,也可以理解为可以把任何一个变量赋给空接口。有点像Object类
package main
import(
"fmt"
"reflect"
)
//利用一个函数,函数的参数定义为空接口:
func testReflect(i interface{}){
//1.调用TypeOf函数,返回reflect.Type类型数据:
reType := reflect.TypeOf(i) //拿类型
fmt.Println("reType:",reType)
fmt.Printf("reType的具体类型是:%T",reType)
fmt.Println()
//2.调用ValueOf函数,返回reflect.Value类型数据:
reValue :=reflect.ValueOf(i)
fmt.Println("reValue:",reValue) //拿值
fmt.Printf("reValue的具体类型是:%T",reValue)
fmt.Println()
//如果真想获取reValue的数值,要调用Int()方法:返回v持有的有符号整数
num := reValue.Int()
fmt.Printf("Int()后的类型是:%T",num)
fmt.Println()
//reflect.Value类型数据,转回去,可先将reValue转成空接口,再用断言转型:
i2 := reValue.Interface()
//类型断言:
n := i2.(int)
n2 := n + 30
fmt.Println(n2)
}
func main(){
//对基本数据类型进行反射:
//定义一个基本数据类型:
var num int = 100
testReflect(num)
}
运行:
注意点:如果有了reflect.Value类型,想转回原来的类型,可以用reflect.Value类型的Interface方法,转回空接口类型,再断言转型,回到int类型
3、对结构体进行反射
package main
import(
"fmt"
"reflect"
)
//利用一个函数,函数的参数定义为空接口:
func testReflect(i interface{}){
//1.调用TypeOf函数,返回reflect.Type类型数据:
reType := reflect.TypeOf(i)
fmt.Println("reType:",reType)
fmt.Printf("reType的具体类型是:%T",reType)
fmt.Println()
//2.调用ValueOf函数,返回reflect.Value类型数据:
reValue :=reflect.ValueOf(i)
fmt.Println("reValue:",reValue)
fmt.Printf("reValue的具体类型是:%T",reValue)
fmt.Println()
//reValue转成空接口:
i2 := reValue.Interface()
//类型断言:
n,flag := i2.(Student)
if flag == true {//断言成功
fmt.Printf("学生的名字是:%v,学生的年龄是:%v",n.Name,n.Age)
}
}
//定义学生结构体:
type Student struct{
Name string
Age int
}
func main(){
//对结构体类型进行反射:
//定义结构体具体的实例:
stu := Student{
Name : "丽丽",
Age : 18,
}
//反射
testReflect(stu)
}
运行:
4、获取变量的类别
在上面reflect.Type和reflect.Value类型对象的基础上,获取类别(Student是类型,其类别是struct结构体)。相关方法:
reflect.Type.Kind()
reflect.Value.Kind()
package main
import(
"fmt"
"reflect"
)
//利用一个函数,函数的参数定义为空接口:
func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口,也可以理解为我们可以把任何一个变量赋给空接口。
//1.调用TypeOf函数,返回reflect.Type类型数据:
reType := reflect.TypeOf(i)
//2.调用ValueOf函数,返回reflect.Value类型数据:
reValue :=reflect.ValueOf(i)
//获取变量的类别:
//(1)reType.Kind()
k1 := reType.Kind()
fmt.Println(k1)
//(2)reValue.Kind()
k2 := reValue.Kind()
fmt.Println(k2)
//获取变量的类型:
//reValue转成空接口:
i2 := reValue.Interface()
//类型断言:
n,flag := i2.(Student)
if flag == true {//断言成功
fmt.Printf("结构体的类型是:%T",n)
}
}
//定义学生结构体:
type Student struct{
Name string
Age int
}
func main(){
//对结构体类型进行反射:
//定义结构体具体的实例:
stu := Student{
Name : "丽丽",
Age : 18,
}
testReflect(stu)
}
运行:
类型Type和类别Kind的区别:
var num int = 10 num的Type是int , Kind也是int
ar stu Studentstu的 Type是 pkg1.Student , Kind是struct
5、通过反射修改基本类型变量的值
调用reflect.Value的相关方法,SetInt、SetBoolean等等
package main
import(
"fmt"
"reflect"
)
//利用一个函数,函数的参数定义为空接口:
func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口,也可以理解为我们可以把任何一个变量赋给空接口。
reValue :=reflect.ValueOf(i)
//通过SetInt()来改变值:
reValue.Elem().SetInt(40)
}
func main(){
//对基本数据类型进行反射:
//定义一个基本数据类型:
var num int = 100
testReflect(&num) //传入指针地址
fmt.Println(num) //40
}
注意,是改基本类型变量,值拷贝,要传入地址:
testReflect(&num)
因为传入的是一个指针类型,想调用reflect.Value的相关方法,对上面的reValue 变量也得再转一下:
reValue.Elem().SetInt(40)
6、通过反射操作结构体的属性和方法
和Java一样,获取所有的变量和所有的方法,调用方法,方法的首字母必须大写才能有对应的反射的访问权限。相关方法:
- NumField:获取结构体字段的总数
- Field:获取结构体的某一个字段,传i序号0、1、2
- NumMethod:获取结构体中方法的数量
- Method:获取结构体中的某一个方法,传i序号0、1、2
- Call,反射调用方法,形参是一个切片,即调用方法的形参
package main
import(
"fmt"
"reflect"
)
//定义一个结构体:
type Student struct{
Name string
Age int
}
//给结构体绑定方法:
func (s Student) CPrint(){
fmt.Println("调用了Print()方法")
fmt.Println("学生的名字是:",s.Name)
}
func (s Student) AGetSum(n1,n2 int) int{
fmt.Println("调用了AGetSum方法")
return n1 + n2
}
func (s Student) BSet(name string,age int){
s.Name = name
s.Age = age
}
//定义函数操作结构体进行反射操作:
func TestStudentStruct(a interface{}){
//a转成reflect.Value类型:
val := reflect.ValueOf(a)
//通过reflect.Value类型操作结构体内部的字段个数:
n1 := val.NumField()
fmt.Println(n1) //2
//遍历-获取具体的字段的值:
for i := 0; i < n1;i++{
fmt.Printf("第%d个字段的值是:%v",i,val.Field(i))
}
fmt.Println()
//通过reflect.Value类型操作结构体内部的方法个数:
n2 := val.NumMethod()
fmt.Println(n2)
//调用自定义结构体的CPrint()方法:
//调用方法,方法的首字母必须大写才能有对应的反射的访问权限
//方法的顺序按照ASCII的顺序排列的,a,b,c,,,,,,索引:0,1,2,,,,,
val.Method(2).Call(nil) //nil给反射的那个方法传空参
//调用AGetSum方法:
//定义Value的切片:
var params []reflect.Value
params = append(params,reflect.ValueOf(10))
params = append(params,reflect.ValueOf(20))
result := val.Method(0).Call(params)
fmt.Println("AGetSum方法的返回值为:",result[0].Int())
}
func main(){
//定义结构体具体的实例:
s := Student{
Name : "丽丽",
Age : 18,
}
//调用TestStudentStruct反射:
TestStudentStruct(s)
}
修改结构体属性的值:
package main
import(
"fmt"
"reflect"
)
//定义函数操作结构体进行反射操作:
func TestStudentStruct(a interface{}){
//a转成reflect.Value类型:
val := reflect.ValueOf(a)
fmt.Println(val)
n := val.Elem().NumField()
fmt.Println(n)
//修改字段的值:
val.Elem().Field(0).SetString("张三") 注意点2
}
func main(){
//定义结构体具体的实例:
s := Student{
Name : "丽丽",
Age : 18,
}
//调用TestStudentStruct:
TestStudentStruct(&s) 注意点1
fmt.Println(s)
}