一、Golang中的面向对象特性
- Golang中也支持面向对象编程（OOP）,但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。
- Golang中没有类（class），Go语言的结构体（struct）和其它编程语言的类（class）有同等地位，可以理解Golang是基于struct来实现OOP特性的。
- Golang面向对象编程非常简洁，去掉了传统OOP语言的继承、方法重载、构造函数和析构函数、隐藏的this指针等。
- Golang仍然有面向对象编程的继承、封装和多态的特性，只是实现的方式和其它OOP语言不一样，比如，Golang没有extends关键字，继承通过匿名字段来实现。
- Golang面向对象（OOP）很优雅，OOP本身就是语言类型系统的一部分，通过接口（interface）关联，耦合性低，也非常灵活。
二、结构体变量的创建与属性
（一）结构体变量基础
1、什么是结构体与结构体变量
结构体表示的就是同一类事物的抽象，是自定义的数据类型。结构体变量（实例）是结构体的具体表现。可以将Golang中的结构体比喻成其它语言的类，将结构体变量比喻成其它语言类的对象。
2、结构体的声明
- 基本语法
type 结构体名称 struct {
field1 type
field2 type
}
例如：
type User struct { UserName string Age int }
3、创建结构体变量的四种方式
- 方式一 var p1 Person
package main import "fmt" type Person struct { Name string Age int } func main() { // 方式一 var p1 Person fmt.Println(p1) }
- 方式二 var p1 Person = Person{}
package main import "fmt" type Person struct { Name string Age int } func main() { // 方式二/1 var p1 Person = Person{ "lily", 20, } fmt.Println(p1) // 方式二/2 可以指定字段名，不依赖顺序传入 p2 := Person{ Name: "harry", Age: 30, } fmt.Println(p2) //方式二/3 p3 := Person{} p3.Name = "alice" p3.Age = 36 fmt.Print(p3) }
- 方式三 var p1 *Person = new(Person)
package main import "fmt" type Person struct { Name string Age int } func main() { // 方式三 var p1 *Person = new(Person) var p1 *Person = new(Person) /* 此时p1是一个指针类型，如果赋值需要： (*p1).Name = "igon" (*p1).Age = 25 但是，go设计者为了使用方便，已经在底层做了处理，所可以这样写： p1.Name = "igon" p1.Age = 25 */ p1.Name = "igon" p1.Age = 25 fmt.Print(*p1) // 指针取值 {igon 25} }
- 方式四 p1 *Person = &Person
package main import "fmt" type Person struct { Name string Age int } func main() { // 方法四 var p1 *Person = &Person var p1 *Person = &Person{} /* p1是一个指针，访问字段的标准方式是(*p1).Name = "egg", 但是go的设计者为了使用方便在底层进行了处理，所以可以这样写： p1.Name = "egg"，实际底层会对p1变成(*p1) */ p1.Name = "egg" fmt.Println(*p1) }
（二）深入理解结构体变量
- 结构体是数值类型，所以不同结构体之间互不影响
- 结构体在内存中的存在形式
- 结构体中的所有字段在内存中是连续的
- 结构体类型转换
- 结构体中的tag
1、结构体是数值类型，所以不同结构体之间互不影响
结构体字段（field）就是属性，一般是基本数据类型、数组、引用类型等。在创建一个结构体变量后，如果没有给字段赋值，那么字段就是对应类型的默认值。
布尔类型：false， 数值类型：0， 字符串：""， 数组（与元素类型有关）：a [3]int， 则为[0, 0, 0] 指针、slice、map：nil，表示未分配空间
比如：
package main import "fmt" type User struct { Name string Age int } func main() { // 创建结构体变量 var user User fmt.Println(user) // { 0} 分别是空字符串和0 }
不同结构体之间互不影响又是如何体现的呢？
package main import "fmt" type User struct { Name string Age int } func main() { // 创建第一个结构体变量 var u1 User = User{ "alily", 20, } fmt.Println(u1) // {alily 20} // 第二个结构体变量,结构体默认是值拷贝，所以u1与u2是两个不同的数据空间 u2 := u1 fmt.Println(u2) // {alily 20} u2.Name = "tomi" fmt.Println(u1, u2) // {alily 20} {tomi 20} }
2、结构体在内存中的存在形式
看到上述的实例，在内存中是如何存在的呢？
这也能很好的说明结构体是值类型，不同结构体之间是互不干扰的，但是假如想让u2的Name改变，同时影响u1的又当如何呢？
package main import "fmt" type User struct { Name string Age int } func main() { // 创建第一个结构体变量 var u1 User = User{ "alily", 20, } fmt.Println(u1) // {alily 20} // 第二个结构体变量，声明成指针变量 var u2 *User = &u1 fmt.Println(*u2) // {alily 20} u2.Name = "tomi" fmt.Println(u1, *u2) // {tomi 20} {tomi 20} }
这与上面的内存示意图完全不同：
所以，改变u2的值就会改变u1的值，因为u2是一个指针，存储的就是u1的地址。
3、结构体中的所有字段在内存中是连续的
package main import "fmt" type Point struct { x int y int } type Rect struct { leftUp, rightDown Point } type Rect1 struct { leftUp, rightDown *Point } func main() { r1 := Rect{ Point{1, 2}, Point{3, 4}, } r2 := Rect1{ &Point{1, 2}, &Point{3, 4}, } // r1有4个int，在内存中是连续分布的 fmt.Printf("r1.leftUp.x地址为：%p r1.leftUp.y地址为：%p r1.rightDown.x地址为：%p r1.rightDown.y地址：%p \n", &r1.leftUp.x, &r1.leftUp.y, &r1.rightDown.x, &r1.rightDown.y) /* r1.leftUp.x地址为：0xc00000e200 r1.leftUp.y地址为：0xc00000e208 r1.rightDown.x地址为：0xc00000e210 r1.rightDown.y地址: 0xc00000e218 */ // r2有2个*Point类型，它们本身的地址也是连续的 fmt.Printf("r2.leftUp地址为：%p r2.rightDown地址为：%p \n", &r2.leftUp, &r2.rightDown) /* r2.leftUp地址为：0xc000050240 r2.rightDown地址为：0xc000050248 */ // 但是2个*Point类型指向的地址不一定是连续的 fmt.Printf("r2.leftUp地址为：%p r2.rightDown地址为：%p", r2.leftUp, r2.rightDown) /* r2.leftUp地址为：0xc0000140b0 r2.rightDown地址为：0xc0000140c0 */ }
字段地址的连续性有助于在内存中快速取值。
4、结构体类型转换
结构体是用户单独定义的类型，与其它类型进行转换时需要有完全相同的字段（名称、个数、类型）。
package main import "fmt" type A struct { n1 string } type B struct { n1 string } func main() { // 类型转换 var a A var b B a = A(b) fmt.Println(a, b) }
结构体使用type重新取别名，golang中也认为时新的数据类型，但是可以通过类型强制转换。
5、结构体中的tag
结构体中的每个字段可以写上一个tag，该tag通过反射机制获取，常见的场景就是序列化和反序列化。
package main import ( "encoding/json" "fmt" ) type User struct { Name string `json:"name"` Age int `json:"age"` } func main() { // 创建一个结构体变量 user := User{ "kity", 23, } fmt.Println(user) // 将结构体变量序列化 jsonStr, err := json.Marshal(user) if err != nil { fmt.Print(err) } else { fmt.Println(string(jsonStr)) // {"name":"kity","age":23} } }
go中字段名如果大写，那么它只能在本包使用，所以如果需要在其它包encoding/json中去序列化需要大写，但是返回给前端的字段一般习惯是小写字段，所以为了解决这个问题，就使用tag的方式。