golang结构体、接口、反射

struct结构体

• struct用来自定义复杂数据结构,可以包含多个字段属性,可以嵌套;
• go中的struct类型理解为类,可以定义方法,和函数定义有些许区别;
• struct类型是值类型.

struct定义

type User struct {
 Name string
 Age int32
 mess string
}
var user User
var user1 *User = &User{}
// new 会分配结构空间,并初始化为清空为零,不进一步初始化
// new之后需要一个指针来指向这个结构
// make会分配结构空间及其附属空间,并完成其间的指针初始化
// make返回这个结构空间,不另外分配一个指针
var user2 *User = new(User)

struct使用

下面示例中user1和uesr2为指针类型,访问的时候编译器会自动把user1.Name转为(*user1).Name

func main() {
 var user User
 user.Name = "nick"
 user.Age = 18
 user.mess = "lover"
 
 var user1 *User = &User{
 Name: "dawn",
 Age: 21,
 }
 fmt.Println(*user1)
 fmt.Println(user1.Name,(*user1).Name)
 
 var user2 *User = new(User)
 user2.Name = "suoning"
}

构造函数

golang中的struct没有构造函数,可以伪造一个

type User struct {
 Name string
 Age int32
 mess string
}
func NewUser(name string, age int32, mess string) *User {
 return &User{Name:name, Age: age, mess: mess}
}
func main() {
 // user := new(User)
 user := NewUser("suoning",18, "lover")
 fmt.Println(user, user.mess, user.Name, user.Age)
}

内存布局

struct中的所有字段在内存是连续的,布局如下:

var user User
user.Name = "nick"
user.Age = 18
user.mess = "lover"
fmt.Println(user)
fmt.Printf("Name:%p\n", &user.Name)
fmt.Printf("Age: %p\n", &user.Age)
fmt.Printf("mess: %p\n",&user.mess)

方法

方法是作用在特定类型的变量上,因此自定义类型,都可以有方法,而不仅仅是struct。
方法的访问控制也是通过大小控制。
init函数是通过传入指针实现,这样改变struct字段值,因为是值类型.

type User struct {
 Name string
 Age int
 sex string
}
func (this *User) init(name string,age int, sex string) {
 this.Name = name
 this.Age = age
 this.sex = sex
}
func (this User) GetName() string {
 return this.Name
}
func main() {
 var user User
 user.init("nick", 18, "man")
 // (&user).init("nick", 18, "man")
 name := user.GetName()
 fmt.Println(name)
}

匿名字段

如果有冲突的,则最外的优先

type User struct {
 Name string
 Age int
}
type Lover struct {
 User
 sex time.Time
 int
 Age int
}

继承 & 多重继承

一个结构全继承多个结构体,访问通过点。继承字段以及方法
可以起别名,如下面u1(user1),访问user.u1.Age。
如果继承的结构全都拥有同一个字段,通过user.name访问就会报错,必须通过user.user1.name来访问.

type user1 struct {
 name string
 Age int
}
type user2 struct {
 name string
 age int
 sex time.Time
}
type User struct {
 u1 user1 // 别名
 user2
 Name string
 Age int
}
func main() {
 var user User
 user.Name = "nick"
 user.u1.Age = 18
 fmt.Println(user)
}

tag

在go中,首字母大小写有特殊的语法含义,小写包外无法引用。由于需要和其它的系统进行数据交互,例如转成json格式。
这个时候如果用属性名来作为键值可能不一定会符合项目要求。tag在转换成其它数据格式的时候,会使用其中特定的字段作为键值.

import "encoding/json"
type User struct {
 Name string `json:"userName"`
 Age int `json:"userAge"`
}
func main() {
 var user User
 user.Name = "nick"
 user.Age = 18
 
 conJson, _ := json.Marshal(user)
 fmt.Println(string(conJson)) // {"username":"nick","userAge":0}
}

String()

如果实现了String()这个方法,那么fmt默认会调用String().

type name1 struct {
 int 
 string
}
func (this *name1) String() string {
 return fmt.Sprintf("This is String(%s).",this.string)
}
func main() {
 n := new(name1)
 fmt.Println(n) //This is String().
 n.string = "suoning"
 d := fmt.Sprintf("%s",n) // This is String(suoning)
 fmt.Println(d)
}

defer所有错误

func myE() (str string, err error) {
 defer func() {
 if p := recover(); p != nil {
 str, ok := p.(string)
 if ok {
 err = errors.New(str)
 } else {
 err = errors.New("panic")
 }
 // debug.PrintStack()
 }
 }()
 panic("this is panic message")
 return "hello girl",err
}

接口interface

interface类型可以定义一组方法,但是这些不需要实现。并interface不能包含任何变量.
interface类型默认是一个指针.

Interface定义

type Car interface {
 NameGet() string
 Run(n int)
 Stop()
}

Interface实现

• 1.Golang中的接口,不需要显示的实现。只要一个变量,含有接口类型中的所有方法,那么这个变量就实现这个接口。因此golang中没有implement类似的关键字;
• 2.如果一个变量含有了多个interface类型的方法,那么这个变量就实现了多个接口;如果一个变量只含有了1个interface的方部分方法,那么这个变量没有实现这个接口。
• 3.空接口interface{}: 空接口没有任何方法,所以所有类型都实现了空接口。

var a int
var b interface{} // 空接口
b = a

多态

一种事物的多种形态,都可以按照统一的接口进行操作。
例子:

type Car interface {
 NameGet() string
 Run(n int)
 Stop()
}
type BMW struct {
 Name string
}
func (this *BMW) NameGet() string {
 return this.Name
}
func (this *BMW) Run(n int) {
 fmt.Printf("BMW is running of num is %d \n",n)
}
func (this *BMW) Stop() {
 fmt.Printf("BMW is stop \n")
}
type Benz struct {
 Name string
}
func (this *Benz) NameGet() string {
 return this.Name
}
func (this *Benz) Run(n int) {
 fmt.Printf("Benz is running of num is %d \n",n)
}
func (this *Benz) Stop() {
 fmt.Printf("Benz is stop \n")
}
func (this *Benz) ChatUp() {
 fmt.Printf("ChatUp \n")
}
func main() {
 var car Car
 fmt.Println(car)
 
 var bmw BMW = BMW{Name: "宝马"}
 car = &bmw
 fmt.Println(car.NameGet()) // 宝马
 car.Run(1)
 car.Stop()
 
 benz := &Benz{Name: "大奔"}
 car = benz
 fmt.Println(car.NameGet()) // 大奔
 car.Run(2)
 car.Stop()
}

Interface嵌套

一个接可以嵌套在另外的接口
即需要实现2个接口的方法。

type Car interface {
 NameGet() string
 Run(n int)
 Stop()
}
type Used interface {
 Car
 Cheap()
}

类型断言

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

var t int
var x interface{}
x = t
y = x.(int)
y, ok = x.(int)

例子一

func test(i interface{}) {
 // n := i.(int)
 n, ok := i.(int)
 if !ok {
 fmt.Println("error")
 return
 }
 n += 10
 fmt.Println(n)
}
func main() {
 var t1 int
 test(t1)
}

例子二

swithc & type

type Student struct {
 Name string
}
func judgmentType(items ...interface{}) {
 for k, v := range items {
 switch v.(type) {
 case string:
 fmt.Printf("string, %d[%v]\n", k, v)
 case bool:
 fmt.Printf("bool, %d[%v]\n", k, v)
 case int, int32, int64:
 fmt.Printf("int, %d[%v]\n",k, v)
 case float32, float64:
 fmt.Printf("float, %d[%v]\n",k, v)
 case Student:
 fmt.Printf("Student, %d[%v]\n",k, v)
 case *Student:
 fmt.Printf("Student, %d[%p]\n",k, v)
 }
 }
}
func main() {
 stu1 := &Student{Name: "nick"}
 judgmentType(1, 2.2, "learing", stu1)
}

例子三

判断一个变量是否实现了指定接口

type Stringer interface {
 String() string
}
type Mystruct interface {
 
}
type Mystruct2 struct {
 
}
func (this *Mystruct2) String() string {
 return ""
}
func main() {
 var v Mystruct
 var v2 Mystruct2
 v = &v2
 
 if sv, ok := v.(Stringer); ok {
 fmt.Printf("%v implements String(): %s\n",sv.String());
 }
}

反射reflect

reflect包实现了运行时反射,允许程序操作任意类型的对象。
典型用法是用静态类型interface{}保存一个值,
通过调用TypeOf获取其动态类型信息,该函数返回一个Type类型值 。
调用ValueOf函数返回一个Value类型值,该值代表运行时的数据。

func TypeOf(i interface{}) Type

TypeOf返回接口中保存的值的类型,TypeOf(nil)会返回nil。

func ValueOf(i interface{}) Value

ValueOf返回一个初始化为i接口保管的具体值的Value,ValueOf(nil)返回Value零值。

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

const (
 Invalid Kind = 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.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"
func main() {
 var x float64 = 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.Println("value is %1.1e\n", v.Interface()) // value is 5.2e+00
 y := v.Interface().(float64)
 fmt.Println(y)
}

例子二(修改值)

setXX(x)因为传递的是x的值的副本,所以SetXX不能够改x,改动x必须向函数传递x的指针,
SetXX(&x)

// 错误代码
// panic: reflect: reflect.Value.SetFloat using unaddressable value
func main() {
 var a float64
 fv := reflect.ValueOf(&a)
 fv.SetFloat(520.00)
 fmt.Printf("%v\n",a)
}

// 正确的,传指针
func main() {
 var a2 float64
 fv2 := reflect.Value(&a2)
 fv2.Elem().SetFloat(520.00)
 fmt.Printf("%v\n",a2) // 520
}

反射操作结构体

• 1.reflect.Value.NumField() 获取结构体中字段的个数
• 2.reflect.Value.Method(n).Call(nil) 来调用结构体中的方法

例子一(通过反射操作结构体)

import "reflect"
type NotknownType struct {
 s1 string
 s2 string
 s3 string
}
func (n NotknownType) String() string {
 return n.S1 + " & " + n.S2 + " & " + n.S3
}
var secret interface{} = NotKnownType{"Go","C","Python"}
func main() {
 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
 
 for i := 0; i < value.NumField(); i++ {
 fmt.Printf("Field %d: %v\n",i, value.Field(i))
 }
 
 results := value.Method(0).Call(nil)
 fmt.Println(results) // [Go & C & Python]
}

例子二(通过反射修改结构体)

import "reflect"
type T struct {
 A int
 B string
}
func main() {
 t := T{18, "nick"}
 s := reflect.ValueOf(&t).Elem()
 typeOfT := s.Type()
 
 for i := 0; i < s.NumField(); i++ {
 f := s.Field(i)
 fmt.Printf("%d: %s %s = %v\n",i,
 typeOfT.Field(i).Name,f.Type(), f.Interface())
 }
 
 s.Field(0).SetInt(25)
 s.Field(1).SetString("nicky")
 fmt.Println(t)
}
-----
/*
输出:
0: A int = 18
1: B string = nick
{25 nicky}
*/

import "reflect"
type test struct {
 S1 string
 s2 string
 s3 string
}
var s interface{} = &test{
 S1: "s1",
 s2: "s2",
 s3: "s3",
}
func main() {
 val := reflect.ValueOf(s)
 fmt.Println(val)
 fmt.Println(val.Elem())
 fmt.Println(val.Elem().Field(0))
 val.Elem().Field(0).SetString("hehe")
}

例子三(struct tag内部实现)

package main
import (
 "fmt"
 "reflect"
)
type User struct {
 Name string `json:"user_name"`
}
func main() {
 var user User
 userType := reflect.TypeOf(user)
 jsonString := userType.Field(0).Tag.Get("json")
 fmt.Println(jsonString)
}

本文来自:博客园

感谢作者:Csir

查看原文:golang结构体、接口、反射

• 编辑
• 预览