Go语言开发（五）、Go语言面向接口

3、类型断言

interface{}可用于向函数传递任意类型的变量，但对于函数内部，该变量仍然为interface{}类型（空接口类型），而不是传入的实参类型。
接口类型向普通类型的转换称为类型断言(运行期确定)。

func printArray(arr interface{}){
       //arr是空接口,不是数组类型，报错
   　　for _,v:=range arr{
      　　　　fmt.Print(v," ")
      　　}
   　　fmt.Println()
}

可以通过类型断言将接口类型转换为切片类型。

func printArray(arr interface{}){
   //通过断言实现类型转换
   a,_ := arr.([]int)
   for _,v:=range a{
      fmt.Println(v, " ")
   }
   fmt.Println()
}

在使用类型断言时，最好判断断言是否成功。

b,ok := a.(T)
if ok{
...
}

断言失败在编译阶段不会报错，因此，如果不对断言结果进行判断将可能会断言失败导致运行错误。
不同类型变量的运算必须进行显式的类型转换，否者结果可能会溢出，导致出错。
类型断言也可以配合switch语句进行判断。

var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
   fmt.Printf("unexpected type %T", t)       // %T prints whatever type t has
case bool:
   fmt.Printf("boolean %t\n", t)             // t has type bool
case int:
   fmt.Printf("integer %d\n", t)             // t has type int
case *bool:
   fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
case *int:
   fmt.Printf("pointer to integer %d\n", *t) // t has type *int
}

四、接口赋值

可以将一个实现接口的对象实例赋值给接口，也可以将另外一个接口赋值给接口。

1、通过对象实例赋值

将一个类对象实例赋值给一个接口前，要保证类实现了接口的所有方法。

package main

import (
   "fmt"
   "reflect"
)

// 定义接口
type Animal interface {
   eat()
   drink()
   print()
}

type Bird struct {
   Name string
}

func (b *Bird) eat() {
   fmt.Println(b.Name,"eat")
}

func (b *Bird) drink() {
   fmt.Println(b.Name,"drink")
}

func (b *Bird) print() {
   fmt.Println(b.Name,"is Bird")
}

type People struct {
   Name string
}

func (p People) eat() {
   fmt.Println(p.Name,"eat")
}

func (p People) drink() {
   fmt.Println(p.Name,"drink")
}

func (p People) print() {
   fmt.Println(p.Name, "is People.")
}

func main() {
   var bob People = People{"BoB"}
   var people1 Animal = &bob
   people1.print() // BoB is People.
   fmt.Println(reflect.TypeOf(people1)) // *main.People

   var people2 Animal = bob
   people2.print() // BoB is People.
   fmt.Println(reflect.TypeOf(people2)) // main.People

   var pigeon Bird  = Bird{"Jack."}
   var bird1 Animal = &pigeon
   bird1.print() // Jack is Bird.
   fmt.Println(reflect.TypeOf(bird1)) // *main.Bird

   //var bird2 Animal = pigeon // not ok
   //cannot use pigeon (type Bird) as type Animal in assignment:
   //Bird does not implement Animal (drink method has pointer receiver)
}

2、通过接口赋值

var r io.Reader = new(os.File)
var rw io.ReadWriter = r   //not ok

var rw2 io.ReadWriter = new(os.File)
var r2 io.Reader = rw2    //ok

r没有实现Write方法，所以不能赋值给rw。

五、反射机制

Go语言实现了反射，所谓反射就是能检查程序在运行时的状态。
reflect包实现了运行时反射，允许程序操作任意类型的对象。

1、获取Value、Type对象

将变量转化成reflect对象(reflect.Type或者reflect.Value）

t := reflect.TypeOf(i)    //reflect.Type对象
v := reflect.ValueOf(i)   //reflect.Value对象

调用reflect.TypeOf(x)，x首先存储在一个空接口上，然后在作为参数传递给TypeOf函数; Reflect.TypeOf函数内部会解析空接口，接收类型信息。
同理，reflect.ValueOf函数内部会接收到一个value信息。

2、获取对象或者变量的类型

Value.Type()和Value.Kind()方法都可以获取对象或者变量的类型，如果是变量的话，获取到的类型都相同；如果是结构体对象，Value.Type()返回结构体的名称，Value.Kind()返回“struct”；如果是自定义类型，Value.Type()返回自定义类型名称，Value.Kind()返回自定义类型的底层存储类型。因此，Value.Kind()可以用于判断变量是否是结构体。
Kind()描述的是reflection对象的底层类型，而不是静态类型。假如一个reflection对像包含了一个用户自定义的静态类型，Kind()方法返回的是底层数据类型，而不是自定义静态类型。

package main

import (
   "reflect"
   "fmt"
)
type Float float64

type Person struct {
   name string
   age int
}

func main() {

   var x1 int = 8
   value1 := reflect.ValueOf(x1)
   fmt.Println(value1.Type())//int
   fmt.Println(value1.Kind())//int
   var x Float = 3.14
   value2 := reflect.ValueOf(x)
   fmt.Println(value2.Type())//Float
   fmt.Println(value2.Kind())//float64
   person := Person{}
   value3 := reflect.ValueOf(person)
   fmt.Println(value3.Type())//Person
   fmt.Println(value3.Kind())//struct
}

3、获取变量的值和给变量赋值

获取变量的值使用value.Interface()方法，返回一个value的值，类型是interface。给变量赋值需要先判断变量的类型，可以使用Value.Kind()方法，如果变量的类型是reflect.Int，使用Value.SetInt()方法给变量赋值。
如果要修改reflection对象的值，reflection对象的值必须是可settable的。
 Settability(可设置)是reflection Value的一个属性, 并不是所有的reflection Values都拥有Settability属性。Settability属性表示reflection对象是否可以修改创建reflection对象的实际值，可设置取决于reflection对象所持有的原始值。
调用reflect.ValueOf(x)时，x作为参数传递时，首先拷贝x，reflect.ValueOf函数中的interface值是x的拷贝，而不是x本身。如果想要通过reflection修改x, 必须传递一个x指针，获取reflect.Value指针指向的对象，使用reflect.ValueOf(&x).Elem()。

package main

import (
   "reflect"
   "fmt"
)
type Float float64

type Human struct {
   name string
   Age uint8
}

func main() {

   var x1 int = 8
   value1 := reflect.ValueOf(x1)
   fmt.Println(value1.Type())//int
   fmt.Println(value1.Kind())//int

   var x Float = 3.14
   //获取reflect.Value对象，属性Settability为false
   value2 := reflect.ValueOf(x)
   fmt.Println(value2.Type())//Float
   fmt.Println(value2.Kind())//float64
   if value2.Kind() ==reflect.Float64{
      if value2.CanSet(){
         value2.SetFloat(3.1415926)
      }
   }
   fmt.Println(value2)//3.14

   person := Human{"Bauer",30}
   //获取reflect.Value指针指向的对象，属性Settability为true
   value3 := reflect.ValueOf(&person).Elem()
   fmt.Println(value3.Type())//Person
   fmt.Println(value3.Kind())//struct
   fmt.Println(value3)//{Bauer 30}

   field0 := value3.FieldByName("name")
   if field0.Kind() == reflect.String{
      if field0.CanSet(){//私有成员不可设置
         field0.SetString("Bob")
      }
   }
   fmt.Println(value3)//{Bauer 30}

   field1 := value3.FieldByName("Age")
   if field1.Kind() == reflect.Uint8{
      if field1.CanSet(){//公有成员可设置
         field1.SetUint(20)
      }
   }
   fmt.Println(value3)//{Bauer 20}

}

对于结构体，只有公有的成员变量可以被reflect改变值，私有的变量是无法改变值的。

4、获取结构体成员变量的tag信息

由于golang变量大小写和公有私有权限相关，开发者很难按照自己的意愿来定义变量名，因此golang提供了tag机制，用于给变量提供一个标签，标签可以作为一个别名，来给一些存储结构来获取结构体变量名字使用。

type Person struct {
   name string `Country:"CN"`
   age uint8
}
bob := Person{"Bob", 30}
v := reflect.ValueOf(bob)
vt := v.Type()
filed,_ := vt.FieldByName("name")
fmt.Println(filed.Tag.Get("Country"))//CN

六、接口的组合

1、结构体嵌入类型

结构体类型可以包含匿名或者嵌入字段。当嵌入一个类型到结构体中时，嵌入类型的名字充当了嵌入字段的字段名。

package main

import "fmt"

type User struct {
   Name string
   EMail string
}

type Admin struct {
   User
   Level string
}

func (user *User)Notify() error{
   fmt.Printf("User: Sending a Email to %s<%s>\n", user.Name,user.EMail)
   return nil
}

func main() {
   admin := &Admin{
      User: User{
         Name:  "Bauer",
         EMail: "bauer@gmail.com",
      },
      Level: "super",
   }
   admin.Notify()
   admin.User.Notify()
}

当嵌入一个类型，嵌入类型的方法就变成了外部类型的方法，但是当嵌入类型的方法被调用时，方法的接受者是内部类型(嵌入类型)，而非外部类型。
嵌入类型的名字充当着字段名，同时嵌入类型作为内部类型存在，可以使用以下方式的调用方法：
admin.User.Notify()
上述代码通过类型名称来访问内部类型的字段和方法。内部类型的字段和方法也同样被提升到了外部类型，因此可以使用以下方式调用方法：
admin.Notify()
通过外部类型来调用Notify方法，本质上是内部类型的方法。

2、Go语言的方法提升

Go语言中内部类型方法集提升的规则如下：
A、如果S包含一个匿名字段T，S和S的方法集都包含接收者为T的方法提升。
当嵌入一个类型，嵌入类型的接收者为值类型的方法将被提升，可以被外部类型的值和指针调用。
B、对于S类型的方法集包含接收者为T的方法提升
当嵌入一个类型，可以被外部类型的指针调用的方法集只有嵌入类型的接收者为指针类型的方法集，即当外部类型使用指针调用内部类型的方法时，只有接收者为指针类型的内部类型方法集将被提升。
C、如果S包含一个匿名字段T，S和S的方法集都包含接收者为T或者T 的方法提升
当嵌入一个类型的指针，嵌入类型的接收者为值类型或指针类型的方法将被提升，可以被外部类型的值或者指针调用。
D、如果S包含一个匿名字段T，S的方法集不包含接收者为*T的方法提升。
根据Go语言规范里方法提升中的三条规则推导出的规则。当嵌入一个类型，嵌入类型的接收者为指针的方法将不能被外部类型的值访问。

3、接口的组合

GO语言中可以通过接口的组合，创建新的接口，新的接口默认继承组合的接口的抽象方法。

package main

import "fmt"

type IReader interface {
   Read(file string) []byte
}

type IWriter interface {
   Write(file string, data string)
}

// 接口组合,默认继承了IReader和IWriter中的抽象方法
type IReadWriter interface {
   IReader
   IWriter
}

type ReadWriter struct {

}

func (rw *ReadWriter) Read(file string) []byte {
   fmt.Println(file)
   return nil
}

func (rw *ReadWriter) Write(file string, data string) {
   fmt.Printf("filename:%s, contents:%s",file,data)
}

func main() {
   readwriter := new(ReadWriter)
   var irw IReadWriter = readwriter // ok
   irw.Read("abc.txt")
   data := "hello world."
   irw.Write("abc.txt",data)
}