Go语言 - 结构体 | 方法
自定义类型和类型别名
自定义类型
在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型， Go语言中可以使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。例如：
// MyInt 将定义为int类型 type MyInt int func main() { var a MyInt fmt.Println(a) // 0 fmt.Printf("%T \n", a) // main.MyInt }
通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。
类型别名
只是给类型起了个名字,本质上是同一个类型
// Mystring 类型别名 type Mystring = string func main() { var s Mystring fmt.Println(s) // 空 fmt.Printf("%T \n", s) // string }
区别: 自定义类型是生成一个新的类型,类型别名不会产生新的类型
结构体
Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。
Go语言中通过struct来实现面向对象。
- 构造体是值类型
- 是一系列属性的集合
结构体的定义
使用type和struct关键字来定义结构体，具体代码格式如下：
type 类型名 struct {
字段名 字段类型
字段名 字段类型
…
}
- 类型名：标识自定义结构体的名称，在同一个包内不能重复。
- 字段名：表示结构体字段名。结构体中的字段名必须唯一。
- 字段类型：表示结构体字段的具体类型。
结构体实例化
只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。
结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。
var 结构体实例 结构体类型
-
方式一
// 结构体 type Animal struct{ name string colour string age int hobby []string } func main() { // 实例化结构体方式一: var erha = Animal{ name : "二哈", colour : "黑色", age : 2, hobby : []string{"吃", "拆家"}, } fmt.Println(erha) // {二哈 黑色 2 [吃 拆家]} // 结构体支持点访问属性 fmt.Println(erha.name) // 二哈 fmt.Println(erha.colour) // 黑色 fmt.Println(erha.age) // 2 fmt.Println(erha.hobby) // [吃 拆家] // 实例化结构体时不传入属性(字段)值, 那么字段值就是其默认类型的初始值 var jinmao = Animal{} fmt.Println(jinmao.name) // 空 fmt.Println(jinmao.age) // 0 fmt.Println(jinmao.colour) // 空 fmt.Println(jinmao.hobby) // [] }
我们通过.来访问结构体的字段（成员变量）
-
方式二
// 实例化结构体方式二 var samo = new(Animal) fmt.Println(samo) // &{ 0 []} (*samo).name = "萨摩" samo.age = 2 fmt.Println(samo.name, samo.age) // 萨摩 2 var keji = &Animal{} keji.name = "柯基" fmt.Println(keji.name) // 柯基
结构体是值类型,我们可以获取其指针进行赋值
-
方式三
使用值的列表初始化
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
// 初始化结构体简写 var douniu = Animal{ "斗牛", "棕色", 1, []string{"打呼噜", "放屁"}, } fmt.Println(douniu.name, douniu.hobby)
使用这种格式初始化时，需要注意：
- 必须初始化结构体的所有字段。
- 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
- 该方式不能和键值初始化方式混用。
构造函数
Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个Animal的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。
func newAnimal(name, colour string, age int, hobby []string) *Animal { return &Animal{ name : name, colour : colour, age : age, hobby : hobby, } } p := newAnimal("熊二", "棕色", 5, []string{"吃",}) fmt.Println(p)
方法和接收者
Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。
方法的定义格式：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
- 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是
self、this之类的命名。例如，Person类型的接收者变量应该命名为p，Connector类型的接收者变量应该命名为c等。 - 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
- 方法名、参数列表、返回参数：具体格式与函数定义相同
// 函数 谁都可以调用 // 方法 某个具体的类型才能调用的函数 type people struct { name string gender string } // 函数 func test1() { fmt.Println("这是一个函数") } // 方法 这里的p相当python类中的self func (p people)test2() { fmt.Printf("这是people结构体的方法 %s \n", p.name) } func main() { test1() // 这是一个函数 var gtq = people{ name: "光头强", gender: "男", } fmt.Println(gtq.name) // 光头强 gtq.test2() // 这是people结构体的方法 光头强 }
方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
指针接收器与值接收器
type Person struct { name string age int sex int }
-
值接收者
func (值)changeName(name string)：在内部修改值，不会影响外部的值
//修改名字的方法 func (a Person)changeName(name string) { a.name=name fmt.Println(a) } func main() { var p Person=Person{name:"熊二"} p.changeName("熊大") // 熊大 fmt.Println(p) // 熊二 不改变原结构体对象的name属性,因为结构体是值类型,被当做参数传递时,是又拷贝了一份 }
-
指针接受者
func (指针)changeName(name string)：在内部修改值，会影响外部的值
func (a *Person)changeName(name string) { a.name=name fmt.Println(a) } func main() { var p *Person=&Person{name:"熊二"} p.changeName("熊大") // 熊大 fmt.Println(p) // 熊大 }
-
什么时候应该使用指针类型接收者
- 需要修改接收者中的值
- 接收者是拷贝代价比较大的大对象
- 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。
给任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
// 可以给任意类型添加方法 // 不能给别的包定义的类型添加方法 type Myint int func (m Myint) test3(){ fmt.Println("Myint的方法") } func main() { var m Myint m.test3() // Myint的方法 }
非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
结构体的匿名字段
结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
type Person struct { string // 把类型当做字段的名字 int } func main() { p := Person{ "熊二", 5, } fmt.Println(p.string, p.int) // 熊二 5 }
匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
嵌套结构体
一个结构体中可以嵌套包含另一个结构体或结构体指针。
// 地址结构体 type Address struct { Province string City string } // 用户结构体 type User struct { Name string Gender string Address Address } func main() { u := User{ Name: "光头强", Gender: "男", Address: Address{ Province: "森林省", City: "森林市", }, } fmt.Println(u.Name) // 光头强 fmt.Println(u.Address) // {森林省 森林市} fmt.Println(u.Address.Province) // 森林省 }
-
嵌套匿名结构体
当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找
type Info struct { Name string Gender string Address // 匿名结构体 } func main() { var i Info i.Name = "李雷" i.Gender = "男" i.Address.Province = "上海" // 通过匿名结构体.字段名访问 i.City = "上海市" // 直接访问匿名结构体的字段名 }
匿名结构体通常用作变量提升
结构体的“继承”
Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。
// 利用及结构体的嵌套模拟"继承" type animal struct { name string } // 定义animal的方法 func (a *animal) move() { fmt.Printf("%s 会动 \n", a.name) } type Dog struct { colour string *animal } // 定义Dog的方法 func (d *Dog) run() { fmt.Printf("%s 会跑", d.name) // 因为嵌套了animal,所以有name属性 } func main() { var d = Dog{ colour: "黑色", animal: &animal{name:"二哈"}, } d.move() // 二哈 会动 d.run() // 二哈 会跑 }
结构体字段的可见性
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。
结构体与JSON序列化
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。
import ( "encoding/json" "fmt" ) type Student struct { ID int Gender string Name string } func main() { s := Student{ ID: 1, Gender: "男", Name: "熊二", } // 序列化 v, err := json.Marshal(s) if err != nil { fmt.Println("格式错误") } fmt.Println(v) // []byte fmt.Println(string(v)) // {"ID":1,"Gender":"男","Name":"熊二"} str := string(v) // 反序列 var stu = &Student{} json.Unmarshal([]byte(str), stu) fmt.Println(stu) }
