# 结构体(2)




## 方法

```go
// func ChangePersonAge(p *Person, newAge int)
func (p *Person) ChangePersonAge(newAge int) {
	p.age = newAge
}

// ChangePersonAge(&p1, 22)
// p1.ChangePersonAge(22)
```


## 继承

Bike 继承了TranficTool 所有属性和方法
```go
type TranficTool struct {
	Name  string
	Speed int
	Color string
}

// Drive 是交通工具的行驶方法
func (t *TranficTool) Drive() {
	fmt.Printf("%s 正在以 %d 的速度前进\n", t.Name, t.Speed)
}


// Bike 是自行车
type Bike struct {
	// 嵌入了交通工具, 继承了交通工具的属性和方法 (可以上班)
	TranficTool
}
```

## 组合

Bike 继承了TranficTool 所有属性和方法, 同时还组合了PlayTool 的所有的属性的方法(组合的时候避免有相同的字段)
```go
type TranficTool struct {
	Name  string
	Speed int
	Color string
}

// Drive 是交通工具的行驶方法
func (t *TranficTool) Drive() {
	fmt.Printf("%s 正在以 %d 的速度前进\n", t.Name, t.Speed)
}

// PlayTool 是一个表演工具
type PlayTool struct{}

func (p *PlayTool) Play() {
	fmt.Println("开始我的表演: 后空翻")
}

func (b *PlayTool) Jump() {
	fmt.Println("海豚跳： 高级版")
}

// Bike 是自行车
type Bike struct {
	// 嵌入了交通工具, 继承了交通工具的属性和方法 (可以上班)
	TranficTool
	// 嵌套了PlayTool, 继承了PlayTool的方法(可以表演)
	PlayTool
}
```

## 重写

我们继承来的方法 不满足我们的需求，那么我们就需要重写方法

```go
// review的核心逻辑: 优先找方法接收者所属的结构体的方法(优先级最高)
// 如果找不到，再去找嵌入的结构体的方法
// 如果嵌入的结构体也找不到，再去找嵌入的结构体的嵌入结构体的方法
// 直到找到为止
// 等同于重写(Rewrite)，覆盖了之前的继承而来的方法
func (b *Bike) Jump() {
	fmt.Println("海豚跳 基础版")
}
```

重写为程序提供了更高的灵活性(兼容性)

## Json

### 序列化与反序列化

一种常见的序列化的方法，也是 常用于数据传递，也实现服务的复制， 既然数据都复制了也就实现的深拷贝(现在， 不是一个对象的完整服务)

常见的JSON库: json, go-json, 还有些第三方库: https://github.com/json-iterator/go

当前 Go 标准库的 json 库已经足够我们使用, 并且兼容性高，性能也强，最新的版本里面

![alt text](image.png)

+ 序列化：：把结构体序列化为JSON字符串 (obj -> json(bytes)), json.Marshal()
```go
	// 类型转换： []byte -> string (需要字符辩解库: acsic, unicode, gbk, gb18030, gb2312, gbk-sjis-x0213, gb18030-sjis-x0213, gb2312-sjis-x0213, gbk-sjis-x0212, gb18030-sjis-x0212, gb2312-sjis-x0212, gbk-sj)
	// [123 34 78 97 109 101 34 58 34 232 135 170 232 161 140 232 189 166 34 44 34 83 112 101 101 100 34 58 50 48 44 34 67 111 108 111 114 34 58 34 233 187 145 232 137 178 34 125]
	fmt.Println(bikeJson)
	// 编码点 对应的 字符串
	// // 123 34 78 97 109 101 34 58 34 33258 34892 36710 34 44 34 83 112 101 101 100 34 58 50 48 44 34 67 111 108 111 114 34 58 34 40657 33394 34 125 (uicode 码表)
	// {"Name":"自行车","Speed":20,"Color":"黑色"}
	fmt.Println("bike json string: ", string(bikeJson))
```


+ 反序列化: 把JSON字符串 反序列化为结构体 (json(bytes) -> obj), json.Unmarshal()
```go
	// json.Unmarshal()
	bike_cloned := &Bike{}
	if err := json.Unmarshal(bikeJson, bike_cloned); err != nil {
		panic(err)
	}
	fmt.Println("bike source:", bike)
	fmt.Println("bike clone:", bike_cloned)
```

注意基于 Json来复制对象，是有属性无法复制的，比如指针，指针类型无法复制，指针类型需要特殊处理


## Json标签

json标签: 用来告诉json库，如何将结构体字段序列化为JSON字符串

```json
// Name => name
// Speed => speed
// Color => color
{"Name":"自行车","Speed":20,"Color":"黑色"}
```

Json Tag: Struct Tag 核心能力，通过给结构体字段添加标签，来告诉json库，如何将结构体字段序列化为JSON字符串(key 映射关系)

```go
// JSON: {"name":"自行车","speed":20,"color":"黑色"}
type TranficTool struct {
	// `` 表示字符串 都是 Struct Tag, 结构体标签，lib 反射使用
	Name  string `json:"name"`
	Speed int    `json:"speed"`
	Color string `json:"color"`
	move  bool
}
```

