go得快（2）

• 反射

package main

import (
    "fmt"
    "reflect"
)

type Profile struct {
    name string
    age int
    gender string
}




type Person struct {
    name string
    age int
    gender string
}

func (p Person)SayBye()  {
    fmt.Println("Bye")
}

func (p Person)SayHello()  {
    fmt.Println("Hello")
}



func main(){
    //7. 反射
    //7.1 Reflection goes from interface value to reflection object.
    var v7 interface{} = 25
    fmt.Printf("原始接口类型%T, 值为%v \n", v7, v7)
    tt7 := reflect.TypeOf(v7)
    vv7 := reflect.ValueOf(v7)
    fmt.Printf("从接口变量到反射对象：Type对象的类型为 %T \n", tt7)//从接口变量到反射对象：Type对象的类型为 *reflect.rtype
    fmt.Printf("从接口变量到反射对象：Value对象的类型为 %T \n", vv7)//从接口变量到反射对象：Value对象的类型为 reflect.Value
    fmt.Print("\n\n")

    //7.2 Reflection goes from reflection object to interface value.
    v72 := vv7.Interface()
    fmt.Printf("从反射对象到接口变量：新对象的类型为 %T 值为 %v \n", v72, v72)// 从反射对象到接口变量：新对象的类型为 int 值为 25
    fmt.Print("\n\n")

    //7.3 To modify a reflection object, the value must be settable.
    /*
        要让反射对象具备可写性，需要注意两点
        1. 创建反射对象时传入变量的指针
        2. 使用 Elem()函数返回指针指向的数据
    */
    var name73 string = "来一个"
    v73 := reflect.ValueOf(&name73)
    fmt.Println("v73的可写性为:", v73.CanSet())
    v731 := v73.Elem()
    fmt.Println("v731的可写性为:", v731.CanSet())

    v731.SetString("来一个的修改")
    fmt.Println("通过反射修改值，从‘来一个’变成了", v731)
    fmt.Print("\n\n")


    //8. 全面学习反射
    //8.1 用kind()获取类别
    v8 := Profile{}
    t := reflect.TypeOf(v8)
    fmt.Println("Type: ",t)
    fmt.Println("Kind: ",t.Kind())
    /*
    输出：
        Type:  main.Profile
        Kind:  struct
    */

    //8.2 获取方法
    p := &Person{}
    t1 := reflect.TypeOf(p)
    fmt.Println("方法数（可导出的）:", t1.NumMethod())
    fmt.Println("第 1 个方法：", t1.Method(0).Name)
    fmt.Println("第 2 个方法：", t1.Method(1).Name)

    //8.3 动态调用函数（使用索引且无参数），类似通过反射来调用方法 略： http://golang.iswbm.com/en/latest/c02/c02_08.html


    //9. 静态类型与动态类型
    //9.1 静态类型与动态类型
    var i interface{} //i 的静态类型就是 interface{}
    i = 18 //动态类型此时变成了 int 类型
    i = "go编程" //动态类型此时变成了 string 类型
    fmt.Println(i)

    //9.2 iface与eface
    //iface 有一组方法的接口
    //eface 不带方法的接口


    //10. make和new的区别
    //10.1 new 并不常用
    /*
    那么 new 函数到底做了哪些事呢：
    分配内存
    设置零值
    返回指针（重要）
    */
    num := new(int)
    fmt.Println(*num) //打印零值：0

    //10.2 make
    //make 用来为 slice, map 或 chan 类型（注意：也只能用在这三种类型上）分配内存和初始化一个对象

    //切片
    a := make([]int, 2, 10)
    // 字典
    b := make(map[string]int)
    // 通道
    c := make(chan int, 10)
    fmt.Println(a, b, c)


}