自定义类型和类型别名

自定义类型

在Go语言中有一些基本的数据类型,如string整型浮点型布尔等数据类型, Go语言中可以使用type关键字来定义自定义类型。

自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义,也可以通过struct定义。例如:

  1. // MyInt 将定义为int类型
  2. type MyInt int
  3. func main() {
  4. var a MyInt
  5. fmt.Println(a) //
  6. fmt.Printf("%T \n", a) // main.MyInt
  7. }

通过Type关键字的定义,MyInt就是一种新的类型,它具有int的特性。

类型别名

只是给类型起了个名字,本质上是同一个类型

  1. // Mystring 类型别名
  2. type Mystring = string
  3. func main() {
  4. var s Mystring
  5. fmt.Println(s) // 空
  6. fmt.Printf("%T \n", s) // string
  7. }

区别: 自定义类型是生成一个新的类型,类型别名不会产生新的类型

结构体

Go语言中的基础数据类型可以表示一些事物的基本属性,但是当我们想表达一个事物的全部或部分属性时,这时候再用单一的基本数据类型明显就无法满足需求了,Go语言提供了一种自定义数据类型,可以封装多个基本数据类型,这种数据类型叫结构体,英文名称struct。 也就是我们可以通过struct来定义自己的类型了。

Go语言中通过struct来实现面向对象。

  • 构造体是值类型
  • 是一系列属性的集合

结构体的定义

使用typestruct关键字来定义结构体,具体代码格式如下:

  1. type 类型名 struct {
  2. 字段名 字段类型
  3. 字段名 字段类型

  4. }
  • 类型名:标识自定义结构体的名称,在同一个包内不能重复。
  • 字段名:表示结构体字段名。结构体中的字段名必须唯一。
  • 字段类型:表示结构体字段的具体类型。

结构体实例化

只有当结构体实例化时,才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。

结构体本身也是一种类型,我们可以像声明内置类型一样使用var关键字声明结构体类型。

  1. var 结构体实例 结构体类型
  • 方式一

  1. // 结构体
  2. type Animal struct{
  3. name string
  4. colour string
  5. age int
  6. hobby []string
  7. }
  8. func main() {
  9. // 实例化结构体方式一:
  10. var erha = Animal{
  11. name : "二哈",
  12. colour : "黑色",
  13. age : 2,
  14. hobby : []string{"吃", "拆家"},
  15. }
  16. fmt.Println(erha) // {二哈 黑色 2 [吃 拆家]}
  17. // 结构体支持点访问属性
  18. fmt.Println(erha.name) // 二哈
  19. fmt.Println(erha.colour) // 黑色
  20. fmt.Println(erha.age) //
  21. fmt.Println(erha.hobby) // [吃 拆家]
  22. // 实例化结构体时不传入属性(字段)值, 那么字段值就是其默认类型的初始值
  23. var jinmao = Animal{}
  24. fmt.Println(jinmao.name) // 空
  25. fmt.Println(jinmao.age) //
  26. fmt.Println(jinmao.colour) // 空
  27. fmt.Println(jinmao.hobby) // []
  28. }

我们通过.来访问结构体的字段(成员变量)

  • 方式二

  1. // 实例化结构体方式二
  2. var samo = new(Animal)
  3. fmt.Println(samo) // &{ 0 []}
  4. (*samo).name = "萨摩"
  5. samo.age = 2
  6. fmt.Println(samo.name, samo.age) // 萨摩 2
  7.  
  8. var keji = &Animal{}
  9. keji.name = "柯基"
  10. fmt.Println(keji.name) // 柯基

结构体是值类型,我们可以获取其指针进行赋值

  • 方式三

使用值的列表初始化

初始化结构体的时候可以简写,也就是初始化的时候不写键,直接写值:

  1. // 初始化结构体简写
  2. var douniu = Animal{
  3. "斗牛",
  4. "棕色",
  5. 1,
  6. []string{"打呼噜", "放屁"},
  7. }
  8. fmt.Println(douniu.name, douniu.hobby)

使用这种格式初始化时,需要注意:

  1. 必须初始化结构体的所有字段。
  2. 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
  3. 该方式不能和键值初始化方式混用。

构造函数

Go语言的结构体没有构造函数,我们可以自己实现。 例如,下方的代码就实现了一个Animal的构造函数。 因为struct是值类型,如果结构体比较复杂的话,值拷贝性能开销会比较大,所以该构造函数返回的是结构体指针类型。

  1. func newAnimal(name, colour string, age int, hobby []string) *Animal {
  2. return &Animal{
  3. name : name,
  4. colour : colour,
  5. age : age,
  6. hobby : hobby,
  7. }
  8. }
  9. p := newAnimal("熊二", "棕色", 5, []string{"吃",})
  10. fmt.Println(p)

方法和接收者

Go语言中的方法(Method)是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者(Receiver)。接收者的概念就类似于其他语言中的this或者 self

方法的定义格式:

  1. func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
  2. 函数体
  3. }
  • 接收者变量:接收者中的参数变量名在命名时,官方建议使用接收者类型名的第一个小写字母,而不是selfthis之类的命名。例如,Person类型的接收者变量应该命名为 pConnector类型的接收者变量应该命名为c等。
  • 接收者类型:接收者类型和参数类似,可以是指针类型和非指针类型。
  • 方法名、参数列表、返回参数:具体格式与函数定义相同
  1. // 函数 谁都可以调用
  2. // 方法 某个具体的类型才能调用的函数
  3. type people struct {
  4. name string
  5. gender string
  6. }
  7.  
  8. // 函数
  9. func test1() {
  10. fmt.Println("这是一个函数")
  11. }
  12. // 方法 这里的p相当python类中的self
  13. func (p people)test2() {
  14. fmt.Printf("这是people结构体的方法 %s \n", p.name)
  15. }
  16. func main() {
  17. test1() // 这是一个函数
  18. var gtq = people{
  19. name: "光头强",
  20. gender: "男",
  21. }
  22. fmt.Println(gtq.name) // 光头强
  23. gtq.test2() // 这是people结构体的方法 光头强
  24. }

方法与函数的区别是,函数不属于任何类型,方法属于特定的类型。

指针接收器与值接收器

  1. type Person struct {
  2. name string
  3. age int
  4. sex int
  5. }
  • 值接收者

  1. func (值)changeName(name string):在内部修改值,不会影响外部的值
  1. //修改名字的方法
  2. func (a Person)changeName(name string) {
  3. a.name=name
  4. fmt.Println(a)
  5. }
  6.  
  7. func main() {
  8. var p Person=Person{name:"熊二"}
  9. p.changeName("熊大") // 熊大
  10. fmt.Println(p) // 熊二 不改变原结构体对象的name属性,因为结构体是值类型,被当做参数传递时,是又拷贝了一份
  11. }
  • 指针接受者

  1. func (指针)changeName(name string):在内部修改值,会影响外部的值
  1. func (a *Person)changeName(name string) {
  2. a.name=name
  3. fmt.Println(a)
  4. }
  5.  
  6. func main() {
  7. var p *Person=&Person{name:"熊二"}
  8. p.changeName("熊大") // 熊大
  9. fmt.Println(p) // 熊大
  10. }
  • 什么时候应该使用指针类型接收者

  1. 需要修改接收者中的值
  2. 接收者是拷贝代价比较大的大对象
  3. 保证一致性,如果有某个方法使用了指针接收者,那么其他的方法也应该使用指针接收者。

给任意类型添加方法

在Go语言中,接收者的类型可以是任何类型,不仅仅是结构体,任何类型都可以拥有方法。 举个例子,我们基于内置的int类型使用type关键字可以定义新的自定义类型,然后为我们的自定义类型添加方法。

  1. // 可以给任意类型添加方法
  2. // 不能给别的包定义的类型添加方法
  3.  
  4. type Myint int
  5.  
  6. func (m Myint) test3(){
  7. fmt.Println("Myint的方法")
  8. }
  9. func main() {
  10. var m Myint
  11. m.test3() // Myint的方法
  12. }

非本地类型不能定义方法,也就是说我们不能给别的包的类型定义方法。

结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型,这种没有名字的字段就称为匿名字段。

  1. type Person struct {
  2. string // 把类型当做字段的名字
  3. int
  4. }
  5.  
  6. func main() {
  7. p := Person{
  8. "熊二",
  9. 5,
  10. }
  11. fmt.Println(p.string, p.int) // 熊二 5
  12. }

匿名字段默认采用类型名作为字段名,结构体要求字段名称必须唯一,因此一个结构体中同种类型的匿名字段只能有一个。

嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针。

  1. // 地址结构体
  2. type Address struct {
  3. Province string
  4. City string
  5. }
  6. // 用户结构体
  7. type User struct {
  8. Name string
  9. Gender string
  10. Address Address
  11. }
  12.  
  13. func main() {
  14. u := User{
  15. Name: "光头强",
  16. Gender: "男",
  17. Address: Address{
  18. Province: "森林省",
  19. City: "森林市",
  20. },
  21. }
  22. fmt.Println(u.Name) // 光头强
  23. fmt.Println(u.Address) // {森林省 森林市}
  24. fmt.Println(u.Address.Province) // 森林省
  25. }
  • 嵌套匿名结构体

当访问结构体成员时会先在结构体中查找该字段,找不到再去匿名结构体中查找

  1. type Info struct {
  2. Name string
  3. Gender string
  4. Address // 匿名结构体
  5. }
  6.  
  7. func main() {
  8. var i Info
  9. i.Name = "李雷"
  10. i.Gender = "男"
  11. i.Address.Province = "上海" // 通过匿名结构体.字段名访问
  12. i.City = "上海市" // 直接访问匿名结构体的字段名
  13. }
  1. 匿名结构体通常用作变量提升

结构体的“继承”

Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。

  1. // 利用及结构体的嵌套模拟"继承"
  2. type animal struct {
  3. name string
  4. }
  5. // 定义animal的方法
  6. func (a *animal) move() {
  7. fmt.Printf("%s 会动 \n", a.name)
  8. }
  9.  
  10. type Dog struct {
  11. colour string
  12. *animal
  13. }
  14. // 定义Dog的方法
  15. func (d *Dog) run() {
  16. fmt.Printf("%s 会跑", d.name) // 因为嵌套了animal,所以有name属性
  17. }
  18.  
  19. func main() {
  20. var d = Dog{
  21. colour: "黑色",
  22. animal: &animal{name:"二哈"},
  23. }
  24. d.move() // 二哈 会动
  25. d.run() // 二哈 会跑
  26. }

结构体字段的可见性

结构体中字段大写开头表示可公开访问,小写表示私有(仅在定义当前结构体的包中可访问)。

结构体与JSON序列化

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式,键/值对组合中的键名写在前面并用双引号""包裹,使用冒号:分隔,然后紧接着值;多个键值之间使用英文,分隔。

  1. import (
  2. "encoding/json"
  3. "fmt"
  4. )
  5.  
  6. type Student struct {
  7. ID int
  8. Gender string
  9. Name string
  10. }
  11.  
  12. func main() {
  13. s := Student{
  14. ID: 1,
  15. Gender: "男",
  16. Name: "熊二",
  17. }
  18. // 序列化
  19. v, err := json.Marshal(s)
  20. if err != nil {
  21. fmt.Println("格式错误")
  22. }
  23. fmt.Println(v) // []byte
  24. fmt.Println(string(v)) // {"ID":1,"Gender":"男","Name":"熊二"}
  25. str := string(v)
  26. // 反序列
  27. var stu = &Student{}
  28. json.Unmarshal([]byte(str), stu)
  29. fmt.Println(stu)
  30. }

Go语言 - 结构体 | 方法的更多相关文章

  1. C语言结构体定义的几种方法

    什么是结构体? 在C语言中,结构体(struct)指的是一种数据结构,是C语言中聚合数据类型(aggregate data type)的一类.结构体可以被声明为变量.指针或数组等,用以实现较复杂的数据 ...

  2. Go 语言 结构体和方法

    @ 目录 1. 结构体别名定义 2. 工厂模式 3. Tag 原信息 4. 匿名字段 5. 方法 1. 结构体别名定义 变量别名定义 package main import "fmt&quo ...

  3. Go语言结构体(struct)

    Go 语言结构体 Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型. 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合. 结构体表示一项记录,比如保存图 ...

  4. 对嵌入式开发C语言结构体的一点总结

    今天冬至居然不上班,公司的良心啊!这回有心情写博客和日志了,好了,废话不多说.直接看下文: 鉴于嵌入式开发过程中,C语言结构体的使用当然是必不可少.话说,基础什么的比你会更牛逼的算法更重要,基础不牢, ...

  5. 在C语言结构体中添加成员函数

    我们在使用C语言的结构体时,经常都是只定义几个成员变量,而学过面向对象的人应该知道,我们定义类时,不只是定义了成员变量,还定义了成员方法,而类的结构和结构体非常的相似,所以,为什么不想想如何在C语言结 ...

  6. 将c语言的结构体定义变成对应的golang语言的结构体定义,并将golang语言结构体变量的指针传递给c语言,cast C struct to Go struct

    https://groups.google.com/forum/#!topic/golang-nuts/JkvR4dQy9t4 https://golang.org/misc/cgo/gmp/gmp. ...

  7. Linux C语言结构体-学习笔记

    Linux C语言结构体简介 前面学习了c语言的基本语法特性,本节进行更深入的学习. 预处理程序. 编译指令: 预处理, 宏定义, 建立自己的数据类型:结构体,联合体,动态数据结构 c语言表达式工具 ...

  8. 读陈浩的《C语言结构体里的成员数组和指针》总结,零长度数组

    原文链接:C语言结构体里的成员数组和指针 复制例如以下: 单看这文章的标题,你可能会认为好像没什么意思.你先别下这个结论,相信这篇文章会对你理解C语言有帮助.这篇文章产生的背景是在微博上,看到@Lar ...

  9. 06. Go 语言结构体

    Go语言结构体(struct) Go 语言通过用自定义的方式形成新的类型,结构体是类型中带有成员的复合类型.Go 语言使用结构体和结构体成员来描述真实世界的实体和实体对应的各种属性. Go 语言中的类 ...

随机推荐

  1. 源码编译安装使用glusterfs+heketi安装使用

    注:使用源码安装的原因主要是使用yum安装glusterfs服务端时出现一些依赖库问题 准备3台glusterfs服务器(官方也建议至少3台,防止发生脑裂),并在各个服务器的/etc/hosts下面添 ...

  2. [转帖]spring boot项目集成jacoco

    小试牛刀:spring boot项目集成jacoco 2019-03-28 20:14:36 zyq23333 阅读数 509   版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议, ...

  3. FusionInsight大数据开发---MapReduce与YARN应用开发

    MapReduce MapReduce的基本定义及过程 搭建开发环境 代码实例及运行程序 MapReduce开发接口介绍 1. MapReduce的基本定义及过程 MapReduce是面向大数据并行处 ...

  4. drools -规则语法

    文章结构 1. 基础api 2. FACT对象 3. 规则 4. 函数 1. 基础api 在 Drools 当中,规则的编译与运行要通过Drools 提供的各种API 来实现,这些API 总体来讲可以 ...

  5. Maven distributionManagement 分发构件至远程仓库

    https://blog.csdn.net/qq827245563/article/details/82661583 maven发布到本地仓库,和私服https://blog.csdn.net/u01 ...

  6. 豆瓣Top250

    """ 爬取豆瓣电影TOP250 - 完整示例代码 """ import codecs import requests from bs4 i ...

  7. Mybatis事物浅谈

    本篇文章主要对Mybatis事物进行基础的介绍.先回顾JDBC事物,再了解Mybatis里面的事物应用. 1.JDBC的事务管理回顾 JDBC的事务管理是基于Connection对象实现的: 开启事务 ...

  8. 学习笔记之Django

    The Web framework for perfectionists with deadlines | Django https://www.djangoproject.com/ Django m ...

  9. JavaScript 之 history对象

    location.history 对象是浏览器的一个历史对象,可以用来前进和后退. 1.back() 方法 history.back(); 浏览器的历史记录会记录原来的地址,这个方法将会返回到上一页. ...

  10. QT制作一个位图画图板程序

    本文学习如何创建一个Qt绘制程序,用户将能够通过使用不同的尺寸和画笔的颜色来表达他们的创造力. 主要功能:保存画板内容为图片.清除画板内容.设置画板大小.设置画笔颜色 新建基于QMainWindow的 ...