经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
GO基础之结构体
来源：cnblogs　　作者：小禾点点　　时间：2019/11/7 20:43:37　　对本文有异议 

  1. 1 、什么是结构体 
    GO语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

2、什么是实例化?

  • Go结构体的定义只是一种内存布局的描述,只有当结构体实例化时,才会真正分配内存。因此必须在定义结构体并实例化后才能使用结构体实例化就是根据结构体定义的格式创建一份与格式一致的內存区域。
  • 结构体实例之间的内存是完全独立的。
  1. package main
  3. import "fmt"
  5. func main() {
  6.     //实例化方式一
  7.     var stu1 Student
  8.     fmt.Printf("stu1=%T,%v,%q \n", stu1, stu1, stu1)
  9.     stu1.name = "zs"
  10.     stu1.age = 12
  11.     stu1.sex = 1
  12.     fmt.Printf("stu1=%T,%v,%q \n", stu1, stu1, stu1)
  13.     //实例化方式二
  14.     stu2 := Student{}
  15.     stu2.name = "David"
  16.     stu2.age = 33
  17.     stu2.sex = 1
  18.     fmt.Printf("stu2=%T,%v,%q \n", stu2, stu2, stu2)
  19.     //实例化方式三
  20.     stu3 := Student{
  21.         name: "Josh",
  22.         age:  28,
  23.         sex:  1,
  24.     }
  25.     fmt.Printf("stu3=%T,%v,%q \n", stu3, stu3, stu3)
  26.     //实例化四
  27.     stu4 := Student{"Ruby", 30, 0}
  28.     fmt.Printf("stu3=%T,%v,%q \n", stu4, stu4, stu4)
  29.     //实例化五
  30.     //使用内置函数new()对结构体进行实例化,结构体实例化后形成指针类型的结构体
  31.     //·new内置函数会分配内存。第一个参数是类型,而不是值,返回的值是指向该类型新分配的零值的指针。该函数用于创建某个类型的指针。
  32.     stu5 := new(Student)
  33.     (*stu5).name = "Running"
  34.     (*stu5).age = 31
  35.     stu5.sex = 0                                     //语法糖的方式
  36.     fmt.Printf("stu3=%T,%v,%q \n", stu5, stu5, stu5) //stu3=*main.Student,&{Running 31 0},&{"Running" '\x1f' '\x00'}
  38. }
  40. //结构体的定义
  41. type Student struct {
  42.     name string
  43.     age  int
  44.     sex  int8
  45. }
View Code

语法糖的概念( Syntactic sugar)

  • 语法糖,也译为糖衣语法,是由英国计算机科学家彼得·约翰·兰达( PeterJ.Landin)发明的一个术语,指计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。
  • 通常来说使用语法糖能够增加程序的可读性,从而减少程序代码岀错的机会
  • 结构体和数组中都含有语法糖。
  1. package main
  3. import "fmt"
  5. func main() {
  6.     arr := [4]int{1, 2, 3, 4}
  7.     arr2 := &arr
  8.     fmt.Println((*arr2)[3])
  9.     //数组中的语法糖
  10.     fmt.Println(arr2[3])
  11.     
  12.     //切片
  13.     arr3 := []int{10, 20, 30, 40}
  14.     arr4 := &arr3
  15.     fmt.Println((*arr4)[3])
  16.     //切片中没有语法糖
  17.     //fmt.Println(arr4[3])
  18. }
View Code

 

3、结构体是值类型传递

二、深拷贝与浅拷贝

struct 默认是深拷贝

  1. package main
  3. import "fmt"
  5. func main() {
  6.     stu1 := Student{"zs", 18, 0}
  7.     fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1)
  8.     //stu1:=main.Student,0xc0000044a0,{zs 18 0}
  9.     stu2 := stu1
  10.     stu2.name = "ls"
  11.     fmt.Printf("stu2:=%T,%p,%v \n", stu2, &stu2, stu2)
  12.     //stu2:=main.Student,0xc000004520,{ls 18 0}
  13.     
  14.     fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1)
  15.     //stu1:=main.Student,0xc0000044a0,{zs 18 0}
  16.     //修改stu2对stu1没有任何影响
  18. }
View Code

 

实现浅拷贝

1、直接赋值指针地址

  1. package main
  3. import "fmt"
  5. func main() {
  6.     stu1 := Student{"zs", 18, 0}
  7.     fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1)
  8.     //stu1:=main.Student,0xc00005a440,{zs 18 0}
  9.     stu2 := &stu1
  10.     stu2.name = "ls"
  11.     fmt.Printf("stu2:=%T,%p,%v \n", stu2, stu2, stu2)
  12.     //stu2:=*main.Student,0xc00005a440,&{ls 18 0}
  14.     fmt.Printf("stu1:=%T,%p,%v \n", stu1, &stu1, stu1)
  15.     //stu1:=main.Student,0xc00005a440,{ls 18 0}
  16.     //修改stu2对stu1有影响
  17. }
View Code

 2、实现结构体浅拷贝：通过new()函数来实例化对象

  1. package main
  3. import "fmt"
  5. func main() {
  6.     //3、实现结构体浅拷贝：通过new()函数来实例化对象
  7.     d4 := new(Dog)
  8.     d4.name = "多多"
  9.     d4.color = "棕色"
  10.     d4.age = 1
  11.     d4.kind = "巴哥犬"
  12.     d5 := d4
  13.     fmt.Printf("d4: %T , %v , %p \n", d4, d4, d4)
  14.     //d4: *main.Dog , &{多多 棕色 1 巴哥犬} , 0xc000040080
  15.     fmt.Printf("d5: %T , %v , %p \n", d5, d5, d5)
  17.     fmt.Println("--------------------------------------")
  19.     d5.color = "金色"
  20.     d5.kind = "金毛"
  21.     fmt.Println("d5修改后：", d5)
  22.     //d5修改后： &{多多 金色 1 金毛}
  23.     fmt.Println("d4：", d4)
  24.     //d4： &{多多 金色 1 金毛}
  25. }
  27. type Dog struct {
  28.     name  string
  29.     color string
  30.     age   int8
  31.     kind  string
  32. }
View Code

 三、struct做函数参数

结构体对象或指针作为函数的参数及函数返回值

  • 结构体对象作为函数参数与结构体指针作为函数参数的不同
  • 结构体对象作为函数返回值与结构体指针作为函数返回值的不同

 

 

四、匿名结构体和匿名字段

匿名结构体

  • •没有名字的结构体。无需通过type关键字定义就可以直接使用。
  • •在创建匿名结构体时，同时要创建对象。
  • •匿名结构体由结构体定义和键值对初始化两部分组成
  1.     //匿名结构体
  2.     addr := struct {
  3.         province, city string
  4.     }{"陕西省", "西安市"}
  5.     fmt.Println(addr)

结构体的匿名字段
结构体中的字段没有名字，只包含一个没有字段名的类型。这些字段被称为匿名字段。

  • •如果字段没有名字，那么默认使用类型作为字段名。
  • •注意：同一个类型只能写一个。
  • •结构体嵌套中采用匿名结构体字段可以模拟继承关系。
  1. package main
  3. import "fmt"
  5. type User struct {
  6.     string
  7.     byte
  8.     int8
  9.     float64
  10. }
  12. func main() {
  13.     //    实例化结构体
  14.     user:= User{"Steven" , 'm' , 35 , 177.5}
  15.     fmt.Println(user)
  16.     //如果想依次输出姓名、年龄、身高、性别
  17.     fmt.Printf("姓名：%s \n" , user.string)
  18.     fmt.Printf("身高：%.2f \n" , user.float64)
  19.     fmt.Printf("性别：%c \n" , user.byte)
  20.     fmt.Printf("年龄：%d \n" , user.int8)
  21. }
View Code

五、结构体的聚合

•将一个结构体作为另一个结构体的属性（字段），这种结构就是结构体嵌套。
•结构体嵌套可以模拟面向对象中的两种关系：

  • 〇聚合关系：一个类作为另_个类的属性
  • 〇继承关系：一个类作为另一个类的子类。子类和父类。
  1. package main
  3. import "fmt"
  5. type Address struct {
  6.     province, city string
  7. }
  9. type Person struct {
  10.     name    string
  11.     age     int
  12.     address *Address
  13. }
  15. func main() {
  16.     //模拟结构体对象之间的聚合关系
  17.     p := Person{}
  18.     p.name = "Steven"
  19.     p.age = 35
  20.  
  21.     //赋值方式1：
  22.     addr := Address{}
  23.     addr.province = "北京市"
  24.     addr.city = "海淀区"
  25.     p.address = &addr
  27.     fmt.Println(p)
  28.     fmt.Println("姓名：", p.name)
  29.     fmt.Println("年龄：", p.age)
  30.     fmt.Println("省：", p.address.province)
  31.     fmt.Println("市：", p.address.city)
  32.     fmt.Println("-----------------------")
  34.     //修改Person对象的数据，是否会影响Address对象的数据？
  35.     p.address.city = "昌平区"
  36.     fmt.Println("姓名：", p.name)
  37.     fmt.Println("年龄：", p.age)
  38.     fmt.Println("省：", p.address.province)
  39.     fmt.Println("市：", p.address.city)
  40.     fmt.Println("addr市：", addr.city) //?是否会受到影响？
  41.     fmt.Println("-----------------------")
  43.     //修改Address对象的数据，是否会影响Person对象的数据？
  44.     addr.city = "大兴区"
  45.     fmt.Println("姓名：", p.name)
  46.     fmt.Println("年龄：", p.age)
  47.     fmt.Println("省：", p.address.province)
  48.     fmt.Println("市：", p.address.city)
  49.     fmt.Println("addr市：", addr.city) //?是否会受到影响？
  50.     fmt.Println("-----------------------")
  52.     //赋值方式2
  53.     p.address = &Address{
  54.         province: "陕西省",
  55.         city:     "西安市",
  56.     }
  57.     fmt.Println(p)
  58.     fmt.Println("姓名：", p.name)
  59.     fmt.Println("年龄：", p.age)
  60.     fmt.Println("省：", p.address.province)
  61.     fmt.Println("市：", p.address.city)
  62.     fmt.Println("-----------------------")
  63. }
View Code

六、结构体嵌套模拟继承关系

•继承是传统面向对象编程中三大特征之一。用于描述两个类之间的关系。一个类（子类、派生类）继承于另一个类（父类、超类）。
•子类可以有自己的属性和方法，也可以重写父类已有的方法。
•子类可以直接访问父类所有的属性和方法。
•提升字段：
　　〇在结构体中属于匿名结构体的字段称为提升字段，因为它们可以被访问，就好像它们属于拥有匿名结构字段的结构一样。
　　〇换句话说，父类中的字段就是提升字段。
•继承的意义：避免重复代码、扩展类的功能
•采用匿名字段的形式就是模拟继承关系。而模拟聚合关系时一定要采用有名字的结构体作为字段

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Person struct {
  8.     name string
  9.     age  int
  10.     sex  string
  11. }
  13. type Student struct {
  14.     Person
  15.     schoolName string
  16. }
  18. func main() {
  19.     //1、实例化并初始化Person
  20.     p1 := Person{"Steven", 35, "男"}
  21.     fmt.Println(p1)
  22.     fmt.Println("-------------------")
  24.     //2、实例化并初始化Student
  25.     //    写法1：
  26.     s1 := Student{p1, "北航软件学院"}
  27.     printInfo(s1)
  29.     //写法2：
  30.     s2 := Student{Person{"Josh", 30, "男"}, "北外高翻学院"}
  31.     printInfo(s2)
  33.     //写法3：
  34.     s3 := Student{Person: Person{
  35.         name: "Penn",
  36.         age:  19,
  37.         sex:  "男",
  38.     },
  39.         schoolName: "北大元培学院",
  40.     }
  41.     printInfo(s3)
  43.     //    写法4：
  44.     s4 := Student{}
  45.     s4.name = "Daniel"
  46.     s4.sex = "男"
  47.     s4.age = 12
  48.     s4.schoolName = "北京十一龙樾"
  49.     printInfo(s4)
  51. }
  53. func printInfo(s1 Student) {
  54.     fmt.Println(s1)
  55.     fmt.Printf("%+v \n", s1)
  56.     fmt.Printf("姓名：%s， 年龄：%d ， 性别：%s ，学校：%s \n", s1.name, s1.age, s1.sex, s1.schoolName)
  57.     fmt.Println("-------------------")
  58. }
View Code

 

七、结构体中的方法

 

• Go语言同时有函数和方法，方法的本质是函数，但是方法和函数又具有不同点。
1、 含义不同
•函数function是一段具有独立功能的代码，可以被反复多次调用，从而实现代码复用。而方法method是一个类的行为功能，只有该类的对象才能调用。
2、 方法有接受者，而函数无接受者
• Go语言的方法methods—种作用于特定类型变量的函数。这种特定类型变量叫做Receiver (接受者、接收者、接收器）。
•接受者的概念类似于传统面向对象语言中的this或self关键字。
• Go语言的接受者强调了方法具有作用对象，而函数没有作用对象。
•—个方法就是一个包含了接受者的函数。
• Go语言中，接受者的类型可以是任何类型，不仅仅是结构体，也可以是struct类型外的其他任何类型。
3、 函数不可以重名，而方法可以重名
•只要接受者不同，则方法名可以一样。

  1. package main
  3. import "fmt"
  4. import "base"
  5. type Employee struct {
  6.     name , currency string
  7.     salary float64
  8. }
  9. func main() {
  10.     emp1 := Employee{"Daniel" , "$" , 2000}
  11.     emp1.printSalary()//员工姓名：Daniel ，薪资：$2000.00 
  12.     emp1.updateSalary(1000)
  13.     emp1.printSalary()//员工姓名：Daniel ，薪资：$1000.00 
  14. }
  16. //printSalary方法
  17. func (e Employee) printSalary() {
  18.     fmt.Printf("员工姓名：%s ，薪资：%s%.2f \n", e.name , e.currency , e.salary)
  19. }
  20. func (e *Employee) updateSalary(num float64)  {
  21.     e.salary=num
  22. }
View Code

方法的继承与重写

  1. package main
  3. import "fmt"
  4. import "base"
  6. type Human struct {
  7.     name, phone string
  8.     age         int
  9. }
  11. type Student struct {
  12.     Human
  13.     school string
  14. }
  16. type Employee struct {
  17.     Human
  18.     company string
  19. }
  21. func main() {
  22.     s1 := Student{Human{"Daniel", "15012345678", 13}, "十一龙樾"}
  23.     e1 := Employee{Human{"Steven", "17812345678", 35}, "1000phone"}
  24.     s1.printName()
  25.     e1.printName()
  26.     s1.SayHi()
  27.     e1.SayHi()
  28. }
  29. //======================方法的继承=============================
  30. func (h *Human) printName() {
  31.     fmt.Println("大家好！我是%s ", h.name)
  32. }
  34. //=====================方法的重写=============================
  35. func (h *Human) SayHi() {
  36.     fmt.Printf("大家好！我是%s ， 我%d岁 ， 联系方式：%s \n", h.name, h.age, h.phone)
  37. }
  39. func (s *Student) SayHi() {
  40.     fmt.Printf("大家好！我是%s ， 我%d岁 ， 我在%s上学，联系方式：%s \n", s.name, s.age, s.school, s.phone)
  41. }
  43. func (e *Employee) SayHi() {
  44.     fmt.Printf("大家好！我是%s ， 我%d岁 ， 我在%s工作，联系方式：%s \n", e.name, e.age, e.company, e.phone)
  45. }
View Code

 

原文链接：http://www.cnblogs.com/jalja/p/11795509.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang 模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号