七、golang中接口、反射

pyrene · · 809 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

一、接口定义

1、定义

interface类型可以定义一组方法,但是这些不需要实现,并且interface不能包含任何变量

package main

import (
   "fmt"
)

type test interface{
   print()
}

type Student struct{
   name string
   age int
   score int
}

func (p *Student)print(){
   fmt.Println("name",p.name)
   fmt.Println("age",p.age)
   fmt.Println("score",p.score)
}

func main(){
   var t test              //创建接口对象
   var stu Student=Student{   //实例化结构体
      name:"stu1",
      age:20,
      score:100,
   }
   t=&stu     //把实例化传给这个接口对象
   t.print()     //接口对象来调用接口的方法
}
name stu1
age 20
score 100
上面的test就是一种类型

 

多态:

一种食物的多种形态,都可以按照统一的接口进行操作

上面的t可以指向Stu,也可以指向其他类型,这个就是多态

定义:

   比如:

   type  example interface{

         method1(参数列表) 返回值列表

   method2(参数列表) 返回值列表

}

interface类型默认是一个指针

接口实现:

a、golang中的接口,不需要显示的实现,只要一个变量,含有接口类型中的所有方法,那么这个变量就实现这个接口

b、如果一个变量含有多个interface类型的方法,那么这个变量就实现了多个接口

c、要实现变量中接口的所有方法,才是实现了这个接口

 

接口嵌套:

一个接口可以嵌套在另外的接口,如下所示

type ReadWrite interface{

         Read(b Buffer) bool

         Write(b Buffer)bool

}

type Lock interface{

         Lock()

         Unlock()

}

type File interface{

         ReadWrite

         Lock

         Close()

}

类型断言

类型断言,由于接口是一般类型,不知道具体类型,如果要转成具体类型,可以采用以下方法进行转换

 

var t int              var t int

var x interface{}    var x interface {}

x=t              x=t

y=x.(int)//转成int  y ,ok=x.(int)  //转成int,带检查

二叉排序树

时间复杂度和二分查找时间复杂度是一样的

 

为什么要使用接口?

接口是一个规范,不需要关注类等的实现。即,数据本来在mysql里面然后突然变成pg里面,只要接口不变,使用方就不需要更改

 

如果接口里面没有任何方法,那么我们就叫这个接口为空接口

 

package main

import (
   "fmt"
)

type Carer interface{
   GetName() string
   Run()
   DIDI()
}

func main(){
   var car Carer
   fmt.Println(car)  //<nil>
}
上面打印出这个接口的值为nil

下面具体接口的用法:

 

package main

import (
   "fmt"
)

type Carer interface{
   GetName() string   //这里前面定义的方法,后面代表返回值类型
   Run()
   DIDI()
}

type BWM struct{
   Name string
}

func (p *BWM)GetName() string{
   return p.Name
}

func (p *BWM)Run(){
   fmt.Printf("%s is Running",p.Name)
}

func (p *BWM)DIDI(){
   fmt.Printf("%s is didi",p.Name)
}

func main(){
   var car Carer
   fmt.Println(car)  //<nil>

   bwm:=BWM{
      Name:"bwm",
   }
   car=&bwm
   car.Run()
}

 

 

接口操作小结:

1、定义接口和方法,注意返回值

2、定义类型

3、定义类型实现的接口的方法,注意这里要实现接口所有的方法

4、声明定义的类型,声明接口变量的类型并且初始化,并把定义的类型赋值给接口变量的类型,注意指针

5、用定义的接口变量执行接口方法

鸭子类型

只要实现了接口相关的协议,那么这个就是接口

 

如sort只需要实现下面的接口就可以

func Sort(data Interface) 这里只需要传入接口就可以了

这个接口实现下面的方法

type Interface interface{

         Len() int           长度

         Less(I,j int) bool     比较两个数

         Swap(I,j int)        交换两个数

}

注意下面的大小写

 

package main

import (
   "fmt"
   "math/rand"

   "sort"
)

type Student struct{
   Name string
   Id string
   Age int
}

type StudentArray []Student  //定义这个是切片结构体

func (p StudentArray) Len() int {
   return len(p)
}

func (p StudentArray)Less(i,j int)bool{
   return p[i].Name>p[j].Name      //从大到小
}

func (p StudentArray)Swap(i,j int){
   p[i],p[j]=p[j],p[i]
}

func main() {
   var stus StudentArray
   for i := 0; i < 10; i++ {
      stu := Student{
         Name: fmt.Sprintf("stu%d", rand.Intn(100)),
         Id:   fmt.Sprintf("110%d", rand.Int()),
         Age:  rand.Intn(100),
      }

      stus = append(stus, stu)
   }

   for _, v := range stus {
      fmt.Println(v)
   }
   //空行
   fmt.Println("\n\n")
   //由于这里实现了sort的接口,所以这里可以直接调用
   sort.Sort(stus)         
   for _, v := range stus {
      fmt.Println(v)
   }
}

反射

反射,可以在运行时动态获取变量的相关信息

import (“reflect”)

两个函数

a)reflect.TypeOf,获取变量的类型,返回reflect.Type类型

b)reflect.ValueOf 获取变来那个的值,返回reflect.Value类型

c) reflect.Value.Kind 获取变量的类别,返回一个变量

d) reflect.value.Interface()  转换成interface类型

 

a和c的区别:

类型和类别的区别

类别范围》类型

 

package main

import(
   "fmt"
   "reflect"
)

type Student struct{
   Name string
   Age int
   Score float32
}

func test(b interface {}){
   t:=reflect.TypeOf(b)
   fmt.Println(t)   //main.Student  类型

   v:=reflect.ValueOf(b)
   k:=v.Kind()
   fmt.Println(k)    //struct类别

   iv:=v.Interface()
   stu,ok:=iv.(Student)
   if ok{
      fmt.Printf("%v %T\n",stu,stu)//{stu01 18 92} main.Student
   }
}

func main(){
   var a Student=Student{
      Name:"stu01",
      Age:18,
      Score:92,
   }
   test(a)
}
可以在动态运行时的时候的到b的很多信息,这就是反射
上面是三种转换

下main是获取值
package main

import(
   "fmt"
   "reflect"
)

type Student struct{
   Name string
   Age int
   Score float32
}

func test(b interface {}){
   t:=reflect.TypeOf(b)
   fmt.Println(t)   //main.Student  类型

   v:=reflect.ValueOf(b)
   k:=v.Kind()
   fmt.Println(k)    //struct类别

   iv:=v.Interface()
   stu,ok:=iv.(Student)
   if ok{
      fmt.Printf("%v %T\n",stu,stu)//{stu01 18 92} main.Student
   }
}

func testInt(b interface{}){
   val :=reflect.ValueOf(b)
   c:=val.Int()           //获取值
   fmt.Printf("get value interface{} %d",c)//get value interface{} 1234
}

func main(){
   var a Student=Student{
      Name:"stu01",
      Age:18,
      Score:92,
   }
   test(a)
   testInt(1234)
}
小结:
1、反射获取具体的了类型
2、转化为具体的值
3、.Int()等获取具体的值
4、才能打印输出值

  

 


有疑问加站长微信联系

本文来自:博客园

感谢作者:pyrene

查看原文:七、golang中接口、反射

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:812540095

809 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传