go语言之行--接口(interface)、反射(reflect)详解

发布时间：2020-12-16 19:34:47 所属栏目：大数据来源：网络整理

导读：一、interface简介 interface(接口)是golang最重要的特性之一，Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。简单的说： interface是方法的集合 interface是一种类型，并且是指针类型 interface的更重要的作用在于

一、interface简介

interface(接口)是golang最重要的特性之一，Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。

简单的说：

interface是方法的集合
interface是一种类型，并且是指针类型
interface的更重要的作用在于多态实现

interface定义

type 接口名称

interface使用

接口的使用不仅仅针对结构体，自定义类型、变量等等都可以实现接口。
如果一个接口没有任何方法，我们称为空接口，由于空接口没有方法，所以任何类型都实现了空接口。
要实现一个接口，必须实现该接口里面的所有方法。

import "fmt"

//定义接口
type Skills interface {
Running()
Getname() string

}

type Student struct {
Name string
Age int
}

// 实现接口
func (p Student) Getname() string{ //实现Getname方法
 fmt.Println(p.Name )
return p.Name
}

func (p Student) Running() { // 实现 Running方法
fmt.Printf("%s running",p.Name)
}
func main() {
var skill Skills
var stu1 Student
stu1.Name = "wd"
stu1.Age = 22
skill = stu1
skill.Running() //调用接口
}

//wd running

多态

上面提到了，go语言中interface是实现多态的一种形式，所谓多态，就是一种事物的多种形态，与python中类的多态是一致的。

同一个interface，不同的类型实现，都可以进行调用，它们都按照统一接口进行操作。

在上面的示例中，我们增加一个Teacher结构体，同样实现接口进行说明：

import "fmt"

type Skills interface {
Running()
Getname() string

}

type Teacher struct {
Name string
Salary int
}

func (p Student) Getname() string{ //实现Getname方法
 fmt.Println(p.Name )
return p.Name
}

func (p Teacher) Getname() string{ //实现Getname方法
 fmt.Println(p.Name )
return p.Name
}

func (p Teacher) Running() { // 实现 Running方法
fmt.Printf("n%s running",p.Name)
}
func main() {
var skill Skills
var stu1 Student
var t1 Teacher
t1.Name = "wang"
stu1.Name = "wd"
stu1.Age = 22
skill = stu1
skill.Running()
skill = t1
t1.Running()
}
//wd running
//wang running

接口嵌套

go语言中的接口可以嵌套，可以理解我继承，子接口拥有父接口的所有方法，并且想要使用该子接口的话，必须将父接口和子接口的所有方法都实现。

type Skills }

type Test interface {
sleeping()
Skills //继承Skills
}

类型转换

由于接口是一般类型，当我们使用接口时候可能不知道它是那个类型实现的，基本数据类型我们有对应的方法进行类型转换，当然接口类型也有类型转换。

当然我们也可以用这个方式来进行类型的判断。

转换方式：

s x x = s
y,ok := x.(int) //将interface 转为int,ok可省略但是省略以后转换失败会报错，true转换成功，false转换失败,并采用默认值

示例：

import "fmt"

func main() {
var x interface{}

s :</span>= <span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;WD</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;
x </span>=<span style="color: #000000;"&gt; s
y,ok :</span>= x.(<span style="color: #0000ff;"&gt;int</span><span style="color: #000000;"&gt;)
z,ok1 :</span>= x.(<span style="color: #0000ff;"&gt;string</span><span style="color: #000000;"&gt;)
fmt.Println(y,ok)
fmt.Println(z,ok1)

}
//0 false
//WD true

判断类型示例：

import "fmt"

type Student struct {
Name string
}

func TestType(items ...interface{}) {
for k,v := range items {
switch v.(type) {
case string:
fmt.Printf("type is string,%d[%v]n",k,v)
case bool:
fmt.Printf("type is bool,v)
case int:
fmt.Printf("type is int,v)
case float32,float64:
fmt.Printf("type is float,v)
case Student:
fmt.Printf("type is Student,v)
case *Student:
fmt.Printf("type is Student,%d[%p]n",v)
}
}
}

func main() {
var stu Student
TestType("WD",100,stu,3.3)
}
//type is string,0[WD]
//type is int,1[100]
//type is Student,2[{}]
//type is float,3[3.3]

二、反射reflect

反射是程序执行时检查其所拥有的结构。尤其是类型的一种能力。这是元编程的一种形式。它同一时候也是造成混淆的重要来源。

每一个语言的反射模型都不同（同一时候很多语言根本不支持反射，python通过hasattr方法实现）

go语言中的反射通过refect包实现，reflect包实现了运行时反射，允许程序操作任意类型的对象。

在介绍反射之前先说明下reflect包中的两个数据类Type和Value。

Type

Type：Type类型用来表示一个go类型。

不是所有go类型的Type值都能使用所有方法。请参见每个方法的文档获取使用限制。在调用有分类限定的方法时，应先使用Kind方法获知类型的分类。调用该分类不支持的方法会导致运行时的panic。

获取Type对象的方法：

func TypeOf(i {}) Type

示例：

import (
"reflect"
"fmt"
)

func main() {
str := "wd"
res_type := reflect.TypeOf(str)
fmt.Println(res_type) //string
}

reflect.Type中方法

通用方法：

*rtype) String() *rtype) Name() *rtype) PkgPath() *rtype) Kind() reflect.Kind *rtype) Size() uintptr *rtype) Align() *rtype) FieldAlign() *rtype) NumMethod() *rtype) Method() reflect.Method *rtype) MethodByName() (reflect.Method,) *rtype) Implements(u reflect.Type) *rtype) ConvertibleTo(u reflect.Type) *rtype) AssignableTo(u reflect.Type) *rtype) Comparable()


 (t *rtype) () reflect.Type

示例：

import (
"fmt"
"reflect"
)

type Skills interface {
reading()
running()
}

}

func (self Student) runing(){
fmt.Printf("%s is runningn",self.Name)
}
func (self Student) reading(){
fmt.Printf("%s is readingn",self.Name)
}
func main() {
stu1 := Student{Name:"wd",Age:22}
inf := new(Skills)
stu_type := reflect.TypeOf(stu1)
inf_type := reflect.TypeOf(inf).Elem() // 特别说明，引用类型需要用Elem()获取指针所指的对象类型
fmt.Println(stu_type.String()) //main.Student
fmt.Println(stu_type.Name()) //Student
fmt.Println(stu_type.PkgPath()) //main
fmt.Println(stu_type.Kind()) //struct
fmt.Println(stu_type.Size()) //24
fmt.Println(inf_type.NumMethod()) //2
fmt.Println(inf_type.Method(0),inf_type.Method(0).Name) // {reading main func() 0} reading
fmt.Println(inf_type.MethodByName("reading")) //{reading main func() 0} true

}

其他方法：

*rtype) Bits()

// 数组

func (t *rtype) Len() int // 获取数组的元素个数

// 映射

func (t *rtype) Key() reflect.Type // 获取映射的键类型

// 通道

func (t *rtype) ChanDir() reflect.ChanDir // 获取通道的方向

// 结构体

func (t rtype) NumField() int // 获取字段数量

func (t rtype) Field(int) reflect.StructField // 根据索引获取字段

func (t rtype) FieldByName(string) (reflect.StructField,bool) // 根据名称获取字段

func (t rtype) FieldByNameFunc(match func(string) bool) (reflect.StructField,bool) // 根据指定的匹配函数 math 获取字段

func (t *rtype) FieldByIndex(index []int) reflect.StructField // 根据索引链获取嵌套字段

// 函数

func (t rtype) NumIn() int // 获取函数的参数数量

func (t rtype) In(int) reflect.Type // 根据索引获取函数的参数信息

func (t rtype) NumOut() int // 获取函数的返回值数量

func (t rtype) Out(int) reflect.Type // 根据索引获取函数的返回值信息

func (t *rtype) IsVariadic() bool // 判断函数是否具有可变参数。
// 如果有可变参数，则 t.In(t.NumIn()-1) 将返回一个切片。

示例：

type Skills interface {
reading()
running()
}

}

func (self Student) runing(){
fmt.Printf("%s is runningn",Age:22}
stu_type := reflect.TypeOf(stu1)
fmt.Println(stu_type.NumField()) //2
fmt.Println(stu_type.Field(0)) //{Name string 0 [0] false}
fmt.Println(stu_type.FieldByName("Age")) //{{Age int 16 [1] false} true
}

Value

不是所有go类型值的Value表示都能使用所有方法。请参见每个方法的文档获取使用限制。在调用有分类限定的方法时，应先使用Kind方法获知该值的分类。调用该分类不支持的方法会导致运行时的panic。

Value为go值提供了反射接口，获取Value对象方法：

func ValueOf(i {}) Value

示例：

str := =

reflect.Value方法

注意：以下所有方法中的v是reflect.Value返回的值。

reflect.Value.Kind()：获取变量类别，返回常量

func main() {
str := "wd"
val := reflect.ValueOf(str).Kind()
fmt.Println(val)//string
}

用于获取值方法：

func (v Value) Int() int64 ) reflect.Value ) reflect.Value ) reflect.Value

设置值方法：

func (v Value) SetInt(x int64) ) ) ) ) )

其他方法：

func (v Value) NumField() ) reflect.Value ) reflect.Value ) reflect.Value ) ) Value ########通道相关：
func (v Value) Send(x reflect.Value)// 发送数据（会阻塞），v 值必须是可写通道。

func (v Value) Recv() (x reflect.Value,ok bool) // 接收数据（会阻塞），v 值必须是可读通道。

func (v Value) TrySend(x reflect.Value) bool // 尝试发送数据（不会阻塞），v 值必须是可写通道。

func (v Value) TryRecv() (x reflect.Value,ok bool) // 尝试接收数据（不会阻塞），v 值必须是可读通道。

func (v Value) Close() // 关闭通道

########函数相关
func (v Value) Call(in []Value) (r []Value) // 通过参数列表 in 调用 v 值所代表的函数（或方法）。函数的返回值存入 r 中返回。
// 要传入多少参数就在 in 中存入多少元素。
// Call 即可以调用定参函数（参数数量固定），也可以调用变参函数（参数数量可变）。

func (v Value) CallSlice(in []Value) []Value // 调用变参函数

示例一：获取和设置普通类型的值

func main() {
str := "wd"
age := 11
fmt.Println(reflect.ValueOf(str).String()) //获取str的值，结果wd
fmt.Println(reflect.ValueOf(age).Int()) //获取age的值，结果age
str2 := reflect.ValueOf(&str) //获取Value类型
str2.Elem().SetString("jack") //设置值
fmt.Println(str2.Elem(),age) //jack 11
}

示例二：简单结构体操作

type Skills interface {
reading()
running()
}

}

func (self Student) runing(){
fmt.Printf("%s is runningn",Age:22}
stu_val := reflect.ValueOf(stu1) //获取Value类型
fmt.Println(stu_val.NumField()) //2
fmt.Println(stu_val.Field(0),stu_val.Field(1)) //wd 22
fmt.Println(stu_val.FieldByName("Age")) //22
stu_val2 := reflect.ValueOf(&stu1).Elem()
stu_val2.FieldByName("Age").SetInt(33) //设置字段值，结果33
 fmt.Println(stu1.Age)

}

示例三：通过反射调用结构体中的方法，通过reflect.Value.Method(i int).Call()或者reflect.Value.MethodByName(name string).Call()实现

func (this *Student) SetName(name string) {
this.Name = name
fmt.Printf("set name %sn",this.Name )
}

func (this *Student) SetAge(age int) {
this.Age = age
fmt.Printf("set age %dn",age )
}

func (this *Student) String() string {
fmt.Printf("this is %sn",this.Name)
return this.Name
}

func main() {
stu1 := &Student{Name:"wd",Age:22}
val := reflect.ValueOf(stu1) //获取Value类型，也可以使用reflect.ValueOf(&stu1).Elem()
val.MethodByName("String").Call(nil) //调用String方法

<span style="color: #0000ff;"&gt;params</span> := make([]reflect.Value,<span style="color: #800080;"&gt;1</span><span style="color: #000000;"&gt;)
</span><span style="color: #0000ff;"&gt;params</span>[<span style="color: #800080;"&gt;0</span>] = reflect.ValueOf(<span style="color: #800080;"&gt;18</span><span style="color: #000000;"&gt;)
val.MethodByName(</span><span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;SetAge</span><span style="color: #800000;"&gt;"</span>).Call(<span style="color: #0000ff;"&gt;params</span>)  <span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;通过名称调用方法</span>

<span style="color: #0000ff;"&gt;params</span>[<span style="color: #800080;"&gt;0</span>] = reflect.ValueOf(<span style="color: #800000;"&gt;"</span><span style="color: #800000;"&gt;jack</span><span style="color: #800000;"&gt;"</span><span style="color: #000000;"&gt;)   
val.Method(</span><span style="color: #800080;"&gt;1</span>).Call(<span style="color: #0000ff;"&gt;params</span>)    <span style="color: #008000;"&gt;//</span><span style="color: #008000;"&gt;通过方法索引调用</span>

fmt.Println(stu1.Name,stu1.Age)
}
//this is wd
//set age 18
//set name jack
//jack 18

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!