go struct 静态函数_Go语言学习笔记(四)结构体struct 接口Interface 反射reflect...
加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号:96933959
结构体struct
struct 用来自定义复杂数据结构,可以包含多个字段(属性),可以嵌套;
go中的struct类型理解为类,可以定义方法,和函数定义有些许区别;
struct类型是值类型。
struct定义
type User struct{
NamestringAge int32
messstring}
varuser Uservar user1 *User = &User{}var user2 *User = new(User)
struct使用
下面示例中user1和user2为指针类型,访问的时候编译器会自动把 user1.Name 转为 (*user1).Name
func main() {varuser User
user.Name= "nick"user.Age= 18user.mess= "lover"
var user1 *User = &User{
Name:"dawn",
Age:21,
}
fmt.Println(*user1) //{dawn 21 }
fmt.Println(user1.Name, (*user1).Name) //dawn dawn
var user2 *User = new(User)
user2.Name= "suoning"user2.Age= 18fmt.Println(user2)//&{suoning 18 }
fmt.Println(user2.Name, (*user2).Name) //suoning suoning
}
构造函数
golang中的struct没有构造函数,可以伪造一个
type User struct{
NamestringAge int32
messstring}
func NewUser(namestring, 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中的所有字段在内存是连续的,布局如下:
varuser User
user.Name= "nick"user.Age= 18user.mess= "lover"fmt.Println(user)//{nick 18 lover}
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:0xc420016198 8字节为内存对齐
方法
方法是作用在特定类型的变量上,因此自定义类型,都可以有方法,而不仅仅是struct。
方法的访问控制也是通过大小写控制。
init函数是通过传入指针实现,这样改变struct字段值,因为是值类型。
type User struct{
NamestringAgeintsexstring}
func (this *User) init(name string, age int, sex string) {this.Name =namethis.Age =agethis.sex =sex
}
func (this User) GetName() string{return this.Name
}
func main() {varuser User
user.init("nick", 18, "man")//(&user).init("nick", 18, "man")
name :=user.GetName()
fmt.Println(name)
}
匿名字段
如果有冲突的, 则最外的优先
type User struct{
Name stirng
Ageint}
type Loverstruct{
User
sex time.TimeintAgeint}
继承 & 多重继承
一个结构体继承多个结构体,访问通过点。继承字段以及方法。
可以起别名,如下面 u1(user1),访问 user.u1.Age。
如果继承的结构体都拥有同一个字段,通过user.name访问就会报错,必须通过user.user1.name来访问。
type user1 struct{
namestringAgeint}
type user2struct{
namestringageintsex time.Time
}
type Userstruct{
u1 user1//别名
user2
NamestringAgeint}
func main() {varuser User
user.Name= "nick"user.u1.Age= 18fmt.Println(user)//{{ 18} { 0 {0 0 }} nick 0}
}
tag
在go中,首字母大小写有特殊的语法含义,小写包外无法引用。由于需要和其它的系统进行数据交互,例如转成json格式。这个时候如果用属性名来作为键值可能不一定会符合项目要求。tag在转换成其它数据格式的时候,会使用其中特定的字段作为键值。
import "encoding/json"type Userstruct{
Namestring `json:"userName"`
Ageint `json:"userAge"`
}
func main() {varuser User
user.Name= "nick"user.Age= 18conJson, _ :=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)ifok {
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()stringRun(nint)
Stop()
}
Interface实现
Golang中的接口,不需要显示的实现。只要一个变量,含有接口类型中的所有方法,那么这个变量就实现这个接口。因此,golang中没有implement类似的关键字;
如果一个变量含有了多个interface类型的方法,那么这个变量就实现了多个接口;如果一个变量只含有了1个interface的方部分方法,那么这个变量没有实现这个接口。
空接口 Interface{}:空接口没有任何方法,所以所有类型都实现了空接口。
var a int
var b interface{} //空接口
b = a
多态
一种事物的多种形态,都可以按照统一的接口进行操作。
栗子:
type Car interface{
NameGet()stringRun(nint)
Stop()
}
type BMWstruct{
Namestring}
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 Benzstruct{
Namestring}
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() {varcar Car
fmt.Println(car)//
var bmw BMW = BMW{Name: "宝马"}
car= &bmw
fmt.Println(car.NameGet())//宝马
car.Run(1) //BMW is running of num is 1
car.Stop() //BMW is stop
benz := &Benz{Name: "大奔"}
car=benz
fmt.Println(car.NameGet())//大奔
car.Run(2) //Benz is running of num is 2
car.Stop() //Benz is stop//car.ChatUp()//ERROR: car.ChatUp undefined (type Car has no field or method ChatUp)
}
Interface嵌套
一个接口可以嵌套在另外的接口。
即需要实现2个接口的方法。
type Car interface{
NameGet()stringRun(nint)
Stop()
}
type Usedinterface{
Car
Cheap()
}
类型断言
类型断言,由于接口是一般类型,不知道具体类型,
如果要转成具体类型,可以采用以下方法进行转换:
var t int
var x interface{}
x=t
y= x.(int) //转成int
y, ok = x.(int) //转成int,不报错
栗子一:
func test(i interface{}) {//n := i.(int)
n, ok := i.(int)if !ok {
fmt.Println("error")return}
n+= 10fmt.Println(n)
}
func main() {var t1 inttest(t1)
}
栗子二:
switch & type
type Student struct{
Namestring}
func judgmentType(items ...interface{}) {for k, v :=range items {switchv.(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)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)
}
}
}
func main() {
stu1 := &Student{Name: "nick"}
judgmentType(1, 2.2, "learing", stu1)
}
栗子三:
判断一个变量是否实现了指定接口
type Stringer interface{
String()string}
type Mystructinterface{
}
type Mystruct2struct{
}
func (this *Mystruct2) String() string{return ""}
func main() {varv Mystructvarv2 Mystruct2
v= &v2if 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.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"func main() {var x float64 = 5.21fmt.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("value is %1.1e\n", v.Interface()) //value is 5.2e+00
y :=v.Interface().(float64)
fmt.Println(y)//5.21
}
栗子二(修改值)
SetXX(x) 因为传递的是 x 的值的副本,所以SetXX不能够改 x,改动 x 必须向函数传递 x 的指针,SetXX(&x) 。
//错误代码!!!//panic: reflect: reflect.Value.SetFloat using unaddressable value
func main() {vara float64
fv := reflect.ValueOf(&a)
fv.SetFloat(520.00)
fmt.Printf("%v\n", a)
}
//正确的,传指针
func main() {vara2 float64
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"type NotknownTypestruct{
S1stringS2stringS3string}
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 Tstruct{
AintBstring}
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 teststruct{
S1strings2strings3string}var s interface{} = &test{
S1:"s1",
s2:"s2",
s3:"s3",
}
func main() {
val :=reflect.ValueOf(s)
fmt.Println(val)//&{s1 s2 s3}
fmt.Println(val.Elem()) //{s1 s2 s3}
fmt.Println(val.Elem().Field(0)) //s1
val.Elem().Field(0).SetString("hehe") //S1大写
}
栗子三(struct tag 内部实现)
package main
import ("fmt"
"reflect")
type Userstruct{
Namestring `json:"user_name"`
}
func main() {varuser User
userType :=reflect.TypeOf(user)
jsonString := userType.Field(0).Tag.Get("json")
fmt.Println(jsonString)//user_name
}
go struct 静态函数_Go语言学习笔记(四)结构体struct 接口Interface 反射reflect...相关推荐
- c语言学习笔记【结构体02】结构体指针变量与结构体变量的函数参数,C语言学习笔记结构体02结构体指针变量与结构体变量的函数参数.docx...
C 语言学习笔记[结构体02]结构体指针变量与结构体变量 的函数参数 C 语言学习笔记之结构体指针变量一提指针,那可 是 C 语言的核心了,有多少学子曾拜倒在指针的脚下.单纯的说指针,其实并不难,但是 ...
- c语言如何宏定义枚举型结构体,C语言学习笔记--枚举结构体
枚举 枚举是一种用户定义的数据类型,它用关键字enum以如下语法格式来声明: enum 枚举类型名字 {名字0,名字1,...,名字n}: 枚举类型名字通常并不真的使用,要用的是大括号里面的名字,因为 ...
- C语言学习笔记---嵌套结构体
结构体不仅可以单独使用,也可以在结构体中嵌套另一个结构体.如下面的例子: struct Date{int year;int month;int day;};struct book{char tit ...
- C语言学习笔记(15)——结构体程序设计
前言 C语言的基本数据类型有整数型.实数型及字符型,使用这些基本数据类型可以构造数组类型,并且可以定义相关数据类型的指针.本节介绍的结构体类型区别于以上任何数据类型,它还能把各种不同类型的数据组合成一 ...
- C语言的几种结构体Struct的赋值方法
C语言的几种结构体Struct的赋值方法 1. 定义结构体类型 这里是两个结构体的基本结构. struct Init{int a;float b;double c; }I1; struct SIMPL ...
- go get 拉取指定版本_go语言学习笔记-基础知识-3
相关文档 go语言学习笔记-目录 1.简介 1.1 什么是GO Go 是一个开源的编程语言,它能让构造简单.可靠且高效的软件变得容易.Go是从2007年末由Robert Griesemer, Rob ...
- 安装成功配置环境变量_go语言学习笔记-Windows10开发环境安装和环境变量配置
相关文档 go语言学习笔记-目录 1.安装 1.1.访问 https://golang.google.cn/dl/ 或 https://golang.org/dl/ 下载官方安装包 1.2.选择Win ...
- go var type 互转_Go语言学习笔记(第九章) 结构体
Go语言基础之结构体 Go语言中没有"类"的概念,也不支持"类"的继承等面向对象的概念.Go 通过类型别名(alias types)和结构体的形式支持用户自定义 ...
- Swift学习笔记-005结构体和类(疯狂swift讲义第二版)
1.定义类及类相关的一切 定义类的一般语法 [修饰符] class 类名{ //类的语句 } 定义结构体的一般语法 [修饰符] class 类名{ //结构体的语句 } 定义存储属性的一般语法 [修饰 ...
最新文章
- 评估指标:ROC,AUC,Precision、Recall、F1-score
- 硬核致敬Linux !30岁生日快乐!
- 基于 qiankun 的微前端应用实践
- cg word List4
- sca标准值_(整理)B超数据标准值.
- 直接插入排序(C语言)实现
- 限制文本框中只能输入数字(+,-)的正则表达式写法
- RobotStudio双传送带系统的搭建
- ②搭建GD32工程模板
- Proteus 数字示波器
- 决策树分析,让你的风险应对更专业
- Failed opening .rdb for saving: Permission denied
- 如何增加微信阅读量,新手公众号如何增加阅读量
- pada aws configuration
- okhttp的视频下载
- 如何实现超大文件(60G)传输给别人?
- 2017百度之星资格赛1003 度度熊与邪恶大魔王(完全背包)
- 留在Facebook:首席运营官桑德伯格否认将加入希拉里政府
- Hadoop——(Hadoop框架,Hadoop的优缺点,Hadoop1.x和2.x的版本区别,Hadoop架构,Hadoop目录结构)
- 经典网页设计:25个应用视差滚动的单页网站
热门文章
- linux命令怎么调wsdl,如何从命令行执行SOAP wsdl Web服务调用
- php清理html table样式,Parse HTML Table - PHP [closed]
- TensorFlow保存和载入训练模型
- C++中的STL--基本概念
- SpringBoot 自带工具类~断言
- 炁体源流 鸿蒙,一人之下:八绝技中最强被曝光,没想到炁体源流落榜,第一在后头...
- 改变mysql的菜单栏的颜色_导航条——动态改变导航菜单的背景颜色
- JAVA进阶教学之(集合)
- JAVA入门级教学之(猜数字测试)
- fopen吃内存吗 php,file_get_contents = PHP致命错误:允许的内存耗尽