浅谈Go语言中的结构体struct & 接口Interface & 反射
结构体struct
struct用来自定义复杂数据结构，可以包含多个字段（属性），可以嵌套；
go中的struct类型理解为类，可以定义方法，和函数定义有些许区别；
struct类型是值类型。
struct定义
typeUserstruct{
Namestring
Ageint32
messstring
}
varuserUser
varuser1*User=&User{}
varuser2*User=new(User)
struct使用
下面示例中user1和user2为指针类型，访问的时候编译器会自动把user1.Name转为(*user1).Name
funcmain(){
varuserUser
user.Name="nick"
user.Age=18
user.mess="lover"
varuser1*User=&User{
Name:"dawn",
Age:21,
}
fmt.Println(*user1)//{dawn21}
fmt.Println(user1.Name,(*user1).Name)//dawndawn
varuser2*User=new(User)
user2.Name="suoning"
user2.Age=18
fmt.Println(user2)//&{suoning18}
fmt.Println(user2.Name,(*user2).Name)//suoningsuoning
}
构造函数
golang中的struct没有构造函数，可以伪造一个
typeUserstruct{
Namestring
Ageint32
messstring
}
funcNewUser(namestring,ageint32,messstring)*User{
return&User{Name:name,Age:age,mess:mess}
}
funcmain(){
//user:=new(User)
user:=NewUser("suoning",18,"lover")
fmt.Println(user,user.mess,user.Name,user.Age)
}
内存布局
struct中的所有字段在内存是连续的
varuserUser
user.Name="nick"
user.Age=18
user.mess="lover"
fmt.Println(user)//{nick18lover}
fmt.Printf("Name:%p\n",&user.Name)//Name:0xc420016180
fmt.Printf("Age:%p\n",&user.Age)//Age:0xc420016190
fmt.Printf("mess:%p\n",&user.mess)//mess:0xc4200161988字节为内存对齐
方法
方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是struct。
方法的访问控制也是通过大小写控制。
init函数是通过传入指针实现，这样改变struct字段值，因为是值类型。
typeUserstruct{
Namestring
Ageint
sexstring
}
func(this*User)init(namestring,ageint,sexstring){
this.Name=name
this.Age=age
this.sex=sex
}
func(thisUser)GetName()string{
returnthis.Name
}
funcmain(){
varuserUser
user.init("nick",18,"man")
//(&user).init("nick",18,"man")
name:=user.GetName()
fmt.Println(name)
}
匿名字段
如果有冲突的，则最外的优先
typeUserstruct{
Namestirng
Ageint
}
typeLoverstruct{
User
sextime.Time
int
Ageint
}
继承&多重继承
一个结构体继承多个结构体，访问通过点。继承字段以及方法。
可以起别名，如下面u1（user1），访问user.u1.Age。
如果继承的结构体都拥有同一个字段，通过user.name访问就会报错，必须通过user.user1.name来访问。
typeuser1struct{
namestring
Ageint
}
typeuser2struct{
namestring
ageint
sextime.Time
}
typeUserstruct{
u1user1//别名
user2
Namestring
Ageint
}
funcmain(){
varuserUser
user.Name="nick"
user.u1.Age=18
fmt.Println(user)//{{18}{0{00}}nick0}
}
tag
在go中，首字母大小写有特殊的语法含义，小写包外无法引用。由于需要和其它的系统进行数据交互，例如转成json格式。这个时候如果用属性名来作为键值可能不一定会符合项目要求。tag在转换成其它数据格式的时候，会使用其中特定的字段作为键值。
import"encoding/json"
typeUserstruct{
Namestring`json:"userName"`
Ageint`json:"userAge"`
}
funcmain(){
varuserUser
user.Name="nick"
user.Age=18
conJson,_:=json.Marshal(user)
fmt.Println(string(conJson))//{"userName":"nick","userAge":0}
}
String()
如果实现了String()这个方法，那么fmt默认会调用String()。
typename1struct{
int
string
}
func(this*name1)String()string{
returnfmt.Sprintf("ThisisString(%s).",this.string)
}
funcmain(){
n:=new(name1)
fmt.Println(n)//ThisisString().
n.string="suoning"
d:=fmt.Sprintf("%s",n)//ThisisString(suoning).
fmt.Println(d)
}
接口Interface
Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。
interface类型默认是一个指针。
Interface定义
typeCarinterface{
NameGet()string
Run(nint)
Stop()
}
Interface实现
Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，golang中没有implement类似的关键字；
如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口；如果一个变量只含有了1个interface的方部分方法，那么这个变量没有实现这个接口。
空接口Interface{}：空接口没有任何方法，所以所有类型都实现了空接口。
varaint
varbinterface{}//空接口
b=a
多态
一种事物的多种形态，都可以按照统一的接口进行操作。
栗子：
typeCarinterface{
NameGet()string
Run(nint)
Stop()
}
typeBMWstruct{
Namestring
}
func(this*BMW)NameGet()string{
returnthis.Name
}
func(this*BMW)Run(nint){
fmt.Printf("BMWisrunningofnumis%d\n",n)
}
func(this*BMW)Stop(){
fmt.Printf("BMWisstop\n")
}
typeBenzstruct{
Namestring
}
func(this*Benz)NameGet()string{
returnthis.Name
}
func(this*Benz)Run(nint){
fmt.Printf("Benzisrunningofnumis%d\n",n)
}
func(this*Benz)Stop(){
fmt.Printf("Benzisstop\n")
}
func(this*Benz)ChatUp(){
fmt.Printf("ChatUp\n")
}
funcmain(){
varcarCar
fmt.Println(car)//
varbmwBMW=BMW{Name:"宝马"}
car=&bmw
fmt.Println(car.NameGet())//宝马
car.Run(1)//BMWisrunningofnumis1
car.Stop()//BMWisstop
benz:=&Benz{Name:"大奔"}
car=benz
fmt.Println(car.NameGet())//大奔
car.Run(2)//Benzisrunningofnumis2
car.Stop()//Benzisstop
//car.ChatUp()//ERROR:car.ChatUpundefined(typeCarhasnofieldormethodChatUp)
}
Interface嵌套
一个接口可以嵌套在另外的接口。
即需要实现2个接口的方法。
typeCarinterface{
NameGet()string
Run(nint)
Stop()
}
typeUsedinterface{
Car
Cheap()
}
类型断言
类型断言，由于接口是一般类型，不知道具体类型，
如果要转成具体类型，可以采用以下方法进行转换：
vartint
varxinterface{}
x=t
y=x.(int)//转成int
y,ok=x.(int)//转成int，不报错
栗子一：
functest(iinterface{}){
//n:=i.(int)
n,ok:=i.(int)
if!ok{
fmt.Println("error")
return
}
n+=10
fmt.Println(n)
}
funcmain(){
vart1int
test(t1)
}
栗子二：
switch&type
typeStudentstruct{
Namestring
}
funcjudgmentType(items...interface{}){
fork,v:=rangeitems{
switchv.(type){
casestring:
fmt.Printf("string,%d[%v]\n",k,v)
casebool:
fmt.Printf("bool,%d[%v]\n",k,v)
caseint,int32,int64:
fmt.Printf("int,%d[%v]\n",k,v)
casefloat32,float64:
fmt.Printf("float,%d[%v]\n",k,v)
caseStudent:
fmt.Printf("Student,%d[%v]\n",k,v)
case*Student:
fmt.Printf("Student,%d[%p]\n",k,v)
}
}
}
funcmain(){
stu1:=&Student{Name:"nick"}
judgmentType(1,2.2,"learing",stu1)
}
栗子三：
判断一个变量是否实现了指定接口
typeStringerinterface{
String()string
}
typeMystructinterface{
}
typeMystruct2struct{
}
func(this*Mystruct2)String()string{
return""
}
funcmain(){
varvMystruct
varv2Mystruct2
v=&v2
ifsv,ok:=v.(Stringer);ok{
fmt.Printf("%vimplementsString():%s\n",sv.String());
}
}
反射reflect
reflect包实现了运行时反射，允许程序操作任意类型的对象。
典型用法是用静态类型interface{}保存一个值，
通过调用TypeOf获取其动态类型信息，该函数返回一个Type类型值。
调用ValueOf函数返回一个Value类型值，该值代表运行时的数据。
funcTypeOf(iinterface{})Type
TypeOf返回接口中保存的值的类型，TypeOf(nil)会返回nil。
funcValueOf(iinterface{})Value
ValueOf返回一个初始化为i接口保管的具体值的Value，ValueOf(nil)返回Value零值。
reflect.Value.Kind
获取变量的类别，返回一个常量
const( InvalidKind=iota Bool Int Int8 Int16 Int32 Int64 Uint Uint8 Uint16 Uint32 Uint64 Uintptr Float32 Float64 Complex64 Complex128 Array Chan Func Interface Map Ptr Slice String Struct UnsafePointer ) reflect.Value.Kind()方法返回的常量
reflect.Value.Interface()
转换成interface{}类型
【变量<-->Interface{}<-->Reflect.Value】
获取变量的值：
reflect.ValueOf(x).Int() reflect.ValueOf(x).Float() reflect.ValueOf(x).String() reflect.ValueOf(x).Bool()
通过反射的来改变变量的值
reflect.Value.SetXX相关方法，比如: reflect.Value.SetInt()，设置整数 reflect.Value.SetFloat()，设置浮点数 reflect.Value.SetString()，设置字符串
栗子一
import"reflect"
funcmain(){
varxfloat64=5.21
fmt.Println("type:",reflect.TypeOf(x))//type:float64
v:=reflect.ValueOf(x)
fmt.Println("value:",v)//value:5.21
fmt.Println("type:",v.Type())//type:float64
fmt.Println("kind:",v.Kind())//kind:float64
fmt.Println("value:",v.Float())//value:5.21
fmt.Println(v.Interface())//5.21
fmt.Printf("valueis%1.1e\n",v.Interface())//valueis5.2e+00
y:=v.Interface().(float64)
fmt.Println(y)//5.21
}
栗子二（修改值）
SetXX(x)因为传递的是x的值的副本，所以SetXX不能够改x，改动x必须向函数传递x的指针，SetXX(&x)。
//错误代码！！！
//panic:reflect:reflect.Value.SetFloatusingunaddressablevalue
funcmain(){
varafloat64
fv:=reflect.ValueOf(&a)
fv.SetFloat(520.00)
fmt.Printf("%v\n",a)
}
//正确的，传指针
funcmain(){
vara2float64
fv2:=reflect.ValueOf(&a2)
fv2.Elem().SetFloat(520.00)
fmt.Printf("%v\n",a2)//520
}
反射操作结构体
reflect.Value.NumField()获取结构体中字段的个数
reflect.Value.Method(n).Call(nil)来调用结构体中的方法
栗子一（通过反射操作结构体）
import"reflect"
typeNotknownTypestruct{
S1string
S2string
S3string
}
func(nNotknownType)String()string{
returnn.S1+"&"+n.S2+"&"+n.S3
}
varsecretinterface{}=NotknownType{"Go","C","Python"}
funcmain(){
value:=reflect.ValueOf(secret)
fmt.Println(value)//Go&C&Python
typ:=reflect.TypeOf(secret)
fmt.Println(typ)//main.NotknownType
knd:=value.Kind()
fmt.Println(knd)//struct
fori:=0;i
栗子二（通过反射修改结构体）
import"reflect"
typeTstruct{
Aint
Bstring
}
funcmain(){
t:=T{18,"nick"}
s:=reflect.ValueOf(&t).Elem()
typeOfT:=s.Type()
fori:=0;i
import"reflect"
typeteststruct{
S1string
s2string
s3string
}
varsinterface{}=&test{
S1:"s1",
s2:"s2",
s3:"s3",
}
funcmain(){
val:=reflect.ValueOf(s)
fmt.Println(val)//&{s1s2s3}
fmt.Println(val.Elem())//{s1s2s3}
fmt.Println(val.Elem().Field(0))//s1
val.Elem().Field(0).SetString("hehe")//S1大写
}
栗子三（structtag内部实现）
packagemain
import(
"fmt"
"reflect"
)
typeUserstruct{
Namestring`json:"user_name"`
}
funcmain(){
varuserUser
userType:=reflect.TypeOf(user)
jsonString:=userType.Field(0).Tag.Get("json")
fmt.Println(jsonString)//user_name
}
以上这篇浅谈Go语言中的结构体struct&接口Interface&反射就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。