golang和java一样都支持反射，可以从变量反向推导出类型方法。

float64反射

先看一个基本类型float64的例子

var x float64 = 5.3
    fmt.Println("type:",reflect.TypeOf(x))
    v := reflect.ValueOf(x)
    fmt.Println("value:",v)
    fmt.Println("type:",v.Type())
    fmt.Println("kind:",v.Kind())
    fmt.Println("value:",v.Float())
    fmt.Println(v.Interface())
    fmt.Printf("value is %5.2e\n",v.Interface())
    y := v.Interface().(float64)
    fmt.Println(y)

结果如下：
type: float64
value: 5.3
type: float64
kind: float64
value: 5.3
5.3
value is 5.30e+00
5.3
可以通过变量x获取到变量的值和类型。

结构体struct反射

结构体的反射也是类似：

type T struct {
    A string
    B struct {
          RenamedC int   `yaml:"c"`
          D        []int `yaml:",flow"`
      }
}
    var x T = T{A:"easy"}
    fmt.Println("type:",v.Kind())
    fmt.Println(v.Interface())
    y := v.Interface().(T)
    fmt.Println(y)

结果如下：
type: main.T
value: {easy {0 []}}
type: main.T
kind: struct
{easy {0 []}}
{easy {0 []}}
当然你可以修改反射后变量：

type Person struct {
    Name string
    Age  int
}

    person := Person{"zhangsan",30}
    v := reflect.ValueOf(&person).Elem()
    fmt.Println(v)

    count := v.NumField()
    fmt.Println("count:",count)
    for i := 0; i < count; i++ {
        field := v.Field(i)
        fmt.Println(field)

        if field.Kind() == reflect.String {
            field.SetString("Test Value")
        }
    }
    fmt.Println(person)

这里需要两点注意的是， 第一结构体元素的首字母要大写，否则会报错： panic: reflect: reflect.Value.SetString using value obtained using unexported field 这个和golang保持一致的风格，大写表示公开。 第二是要使用地址去改变，如果是这样： v := reflect.ValueOf(person)，获取值类型去修改的话，会报错： panic: reflect: reflect.Value.SetString using unaddressable value 报的没法地址到value。 正确的输出结果如下： {zhangsan 30} count: 2 zhangsan 30 {Test Value 30}