反射初识

package main

import (
    "fmt"
    "reflect"
)

//23
func main() {
    /*
    反射操作：通过反射，可以获取一个接口类型变量的 类型和数值

    */
    var x float64 = 3.14

    fmt.Println("type:",reflect.TypeOf(x)) //type: float64

    fmt.Println("value:",reflect.ValueOf(x)) //value: 3.14

    //根据反射的值，来获取对应的类型和数值

    v := reflect.ValueOf(x)
    fmt.Println("kind is float64:",v.Kind() == reflect.Float64) //kind is float64: true

    fmt.Println("type:",v.Type()) //type: float64
    fmt.Println("value:",v.Float()) //value: 3.14

}

reflect对象获取接口变量信息

package main

import (
    "fmt"
    "reflect"
)

//24
func main() {
    /*
    反射操作：通过反射，可以获取一个接口类型变量的 类型和数值

    */
    var num float64 = 1.23

    value := reflect.ValueOf(num)

    convertValue := value.Interface().(float64)

    fmt.Println(convertValue) //1.23

    /*
    反射类型对象 --> 接口类型变量，理解为"强制转换"
    Golang对类型要求非常严格，类型一定要完全符合
    一个是*float64，一个是float64，混淆就会panic
    */
    pointer := reflect.ValueOf(&num)
    convertpointer := pointer.Interface().(*float64)
    fmt.Println(convertpointer) //0xc0000b4008

    p1 := Person{"王二狗",18,"男"}

    GetMessage(p1)

}

func GetMessage(input interface{}){
    getType := reflect.TypeOf(input)
    fmt.Println("get Type is : ",getType.Name()) //get Type is :  Person
    fmt.Println("get Kind is : ",getType.Kind()) //get Kind is :  struct

    getValue := reflect.ValueOf(input)
    fmt.Println("get all Fields is :",getValue) //get all Fields is : {王二狗 18 男}

    //获取字段
    /*
    1。 获取Type对象：reflect.Type
        NumField()
        Field(index)

    2。通过Field()获得每一个Field字段
    3。 Interface()，得到对应的Value
    */
    for i := 0; i < getType.NumField(); i++ {
        field := getType.Field(i)
        value := getValue.Field(i).Interface()
        //字段名称:Name,字段类型：string，字段数值：王二狗
        //字段名称:Age,字段类型：int，字段数值：18
        //字段名称:Sex,字段类型：string，字段数值：男
        fmt.Printf("字段名称:%s,字段类型：%s，字段数值：%v\n",field.Name,field.Type,value)
    }

    //获取方法
    for i := 0; i < getType.NumMethod(); i++ {
        method := getType.Method(i)
        //方法名称：PrintInfo，方法类型：func(main.Person)
        //方法名称：Say，方法类型：func(main.Person, string)
        fmt.Printf("方法名称：%s，方法类型：%v\n",method.Name,method.Type)
    }


}


type Person struct {
    Name string
    Age int
    Sex string
}

func (p Person) Say(msg string) {
    fmt.Println("hello",msg)
}

func (p Person) PrintInfo() {
    fmt.Println("姓名：%s，年龄：%d，性别：%s\n",p.Name,p.Age,p.Sex)
}

reflect对象设置实际变量的值

package main

import (
    "fmt"
    "reflect"
)

//25
func main() {
    /*
        反射操作：通过反射，可以获取一个接口类型变量的 类型和数值

    */

    var num float64 = 1.23

    //需要操作指针
    //通过reflect.ValueOf() 获得num的value对象
    pointer := reflect.ValueOf(&num) //注意参数必须是指针才能修改其值
    newValue := pointer.Elem()

    fmt.Println("类型：",newValue.Type()) //类型： float64
    fmt.Println("是否可以修改:",newValue.CanSet()) //是否可以修改: true

    //重新赋值
    newValue.SetFloat(3.14)
    fmt.Println(num) //3.14

    s1 := Student{"suntong",22}
    fmt.Printf("%T\n",s1) //main.Student

    //反射改变数值
    value := reflect.ValueOf(&s1)
    if value.Kind() == reflect.Ptr {
        newValue2 := value.Elem()
        fmt.Println(newValue2) //{suntong 22}

        f1 := newValue2.FieldByName("Name")
        f1.SetString("zhangsan")
        fmt.Println(s1) //{zhangsan 22}
    }




}

type Student struct {
    Name string
    Age int
}

reflect对象进行方法的调用

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

//26
func main() {
    /*
    通过反射来进行方法的调用
    思路：
    1。 接口变量 -> 对象反射对象：Value
    2. 获取对应的方法对象，MethodByName()
    3. 将方法对象进行调用，Call()
    */
    p1 := Person2{"suntong",22,"男"}
    value := reflect.ValueOf(p1)
    fmt.Printf("kind:%s,type:%s\n",value.Kind(),value.Type()) //kind:struct,type:main.Person2

    methodValue1 := value.MethodByName("PrintInfo")
    //kind:func,type:func()
    fmt.Printf("kind:%s,type:%s\n",methodValue1.Kind(),methodValue1.Type())

    //没有参数，进行调用
    methodValue1.Call(nil) //姓名：suntong，年龄：22，性别：男

    args1 := make([]reflect.Value,0) //空切片
    methodValue1.Call(args1) //姓名：suntong，年龄：22，性别：男

    methodValue2 := value.MethodByName("Say")
    // kind:func,type:func(string)
    fmt.Printf("kind:%s,type:%s\n",methodValue2.Kind(),methodValue2.Type())
    args2 := []reflect.Value{reflect.ValueOf("反射机制")} //多个参数，增加reflect.ValueOf(int/string。。。)
    methodValue2.Call(args2) //hello 反射机制


    //函数的反射
    f5 := fun5
    value1 := reflect.ValueOf(f5)
    fmt.Printf("kind:%s,type:%s\n",value1.Kind(),value1.Type()) //kind:func,type:func()
    value2 := reflect.ValueOf(fun6)
    value3 := reflect.ValueOf(fun7)
    fmt.Printf("kind:%s,type:%s\n",value2.Kind(),value2.Type()) //kind:func,type:func(int, string)
    fmt.Printf("kind:%s,type:%s\n",value3.Kind(),value3.Type()) //kind:func,type:func(int, string) string

    //通过反射调用函数
    //fun5,无参
    //fun6,有参
    //fun5,有参有返回值
    value1.Call(nil)
    value2.Call([]reflect.Value{reflect.ValueOf(1000),reflect.ValueOf("suntong")})
    resultValue := value3.Call([]reflect.Value{reflect.ValueOf(2000),reflect.ValueOf("isuntong")})
    fmt.Printf("%T\n",resultValue) //[]reflect.Value
    fmt.Println(len(resultValue)) //1
    fmt.Printf("kind:%s,type:%s\n",resultValue[0].Kind(),resultValue[0].Type()) //kind:string,type:string

    s := resultValue[0].Interface().(string)
    fmt.Println(s) //isuntong2000
    fmt.Printf("%T\n",s) //string



}

func fun5(){
    fmt.Println("fun5,无参")
}

func fun6(i int,s string){
    fmt.Println("fun6,有参")
}

func fun7(i int,s string)(string){
    fmt.Println("fun5,有参有返回值")
    return s + strconv.Itoa(i)
}


type Person2 struct {
    Name string
    Age int
    Sex string
}

func (p Person2) Say(msg string) {
    fmt.Println("hello",msg)
}

func (p Person2) PrintInfo() {
    fmt.Printf("姓名：%s，年龄：%d，性别：%s\n",p.Name,p.Age,p.Sex)
}