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

一、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() 获取 t 类型的字符串描述，不要通过 String 来判断两种类型是否一致。 *rtype) Name() 获取 t 类型在其包中定义的名称，未命名类型则返回空字符串。 *rtype) PkgPath() 获取 t 类型所在包的名称，未命名类型则返回空字符串。 *rtype) Kind() reflect.Kind 获取 t 类型的类别。 *rtype) Size() uintptr 获取 t 类型的值在分配内存时的大小，功能和 unsafe.SizeOf 一样。 *rtype) Align() 获取 t 类型的值在分配内存时的字节对齐值。 *rtype) FieldAlign() 获取 t 类型的值作为结构体字段时的字节对齐值。 *rtype) NumMethod() 获取 t 类型的方法数量。 *rtype) Method() reflect.Method 获取 t 类型的方法，如果方法不存在，则 panic。 *rtype) MethodByName() (reflect.Method,) 名称获取 t 类型的方法。 *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 running\n",self.Name)
}
func (self Student) reading(){
fmt.Printf("%s is reading\n",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() 获取数值类型的位宽，t 必须是整型、浮点型、复数型

// 数组

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 running\n",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()：获取变量类别，返回常量

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

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

一、interface简介

interface定义

interface使用

多态

接口嵌套

类型转换

二、反射reflect

Type

reflect.Type中方法

Value

reflect.Value方法

猜你在找的Go相关文章