2022-5-7 实习Day30

1、汇款业务-解付业务单元测试文档编写。 –1小时 100%
2、新开核心账号账号不返显问题解决。 –3小时 100%
3、行内汇款-汇入汇款部分数据不返显 –1小时 100%

Golang编程学习（part 25）

1、如果不用对象模式去解决养猫问题缺点分析

① 使用变量或数组来解决养猫问题，不利于数据的管理和维护。因为名字，年龄，颜色都是属于一只猫，但是这里是分开保存的。
② 如果我们希望对一只猫的属性（名字、年龄、颜色）进行操作（绑定方法），也不好处理。
③ 引出我们要讲解的结构体技术

2、Golang语言面向对象编程说明

① Golang也支持面向对象编程（OOP），但是和传统的面向对象编程是有区别的，并不是纯粹的面向对象语言。所以我们说Golang支持面向对象编程特性是比较准确的。
② Golang没有类（class）概念，Golang的结构体（struct）和其他编程语言的类（class）有同等地位，你可以理解Golang是基于struct来实现OOP特性的。
③ Golang面向对象编程非常简洁，去掉了传统的OOP语言的继承、方法重载、构造方法和析构函数、隐藏的this指针等
④ Golang仍然有面向对象编程的继承、封装、多态的特性，只是实现的方法和其他OOP语言不一样。比如继承，Golang中没有extends关键字，继承是通过匿名字段来实现的。
⑤ Golang面向对象（OOP）很优雅，OOP本身就是语言类型系统（type system）的一部分，通过接口（interface）关联，耦合度低，也非常灵活。Golang中面向接口编程是非常重要的特性

3、快速入门-面向对象方式解决养猫问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import "fmt"
// 定义一个Cat结构体，将Cat的各个字段/属性信息，放入到Cat结构体进行管理
type Cat struct {
    Name  string
    Age   int
    Color string
    Hobby string
}

func main() {
    var cat Cat
    cat.Name = "小白"
    cat.Age = 25
    cat.Color = "白色"
    cat.Hobby = "吃鱼<·)))><<"
    fmt.Printf("cat=%v", cat)
}

// cat={小白 25 白色 吃鱼<·)))><<}

4、结构体的字段/属性

① 基本介绍

1）从概念或叫法上看，结构体字段 = 属性 = field（即授课中，统一叫字段）

2）字段是结构体的一个组成部分，一般是基本数据类型、数组，也可以是引用类型。

② 注意事项和细节说明

1）字段声明语法同变量，示例：字段名 字段类型

2）字段的类型可以为：基本类型、数组或引用类型

3）在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值（默认值），规则同前面讲的一样,布尔类型：false，数值：0，字符串：""，数组类型的默认值和它的元素类型相关，比如score [3]int 则为[0,0,0]，指针，slice，和map的零值都是null，即还没有分配空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
type Person struct {
    Name  string
    Age   int
    Score [5]float64
    ptr   *int
    slice []int
    map1  map[string]string
}

func main() {
    // 定义结构体变量
    var p1 Person
    fmt.Println(p1)

    if p1.ptr == nil {
        fmt.Println("ptr is nil")
    }

    if p1.slice == nil {
        fmt.Println("slice is nil")
    }

    if p1.map1 == nil {
        fmt.Println("map1 is nil")
    }

    // 使用slice，再次说明，一定要make
    p1.slice = make([]int, 10)
    p1.slice[0] = 100

    // 使用map，一定要先make
    p1.map1 = make(map[string]string)
    p1.map1["key1"] = "tom~"
    fmt.Println(p1)
}

{ 0 [0 0 0 0 0] <nil> [] map[]}
ptr is nil
slice is nil
map1 is nil
{ 0 [0 0 0 0 0] <nil> [100 0 0 0 0 0 0 0 0 0] map[key1:tom~]}

4）不同结构体变量的字段是独立的，互不影响，一个结构体变量字段发更改，不影响另外一个，结构体是值类型。（结构体变量里面是引用类型的话，是可以修改到值的）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
func main() {
    a := 10
    //b := 20
    // 定义结构体变量
    var p1 Person = Person{Name: "张三",
        Age:   25,
        Score: [5]float64{1, 5, 8, 9, 3},
        ptr:   &a,
        slice: []int{1, 5, 8, 7},
        map1:  map[string]string{"name": "zhangsan"}}

    fmt.Println(p1)
    p2 := p1
    p2.Name = "李四"
    p2.Age = 30
    p2.Score = [5]float64{8, 7, 9, 2, 3}
    *p2.ptr = 40
    p2.slice[0] = 99
    p2.map1["name"] = "lisi"

    fmt.Println(p1)
    fmt.Println(p2)
}

{张三 25 [1 5 8 9 3] 0xc0000aa058 [1 5 8 7] map[name:zhangsan]}
{张三 25 [1 5 8 9 3] 0xc0000aa058 [99 5 8 7] map[name:lisi]}
{李四 30 [8 7 9 2 3] 0xc0000aa058 [99 5 8 7] map[name:lisi]}

5、创建结构体变量和访问结构体字段

① 方式1：直接声明
1
var person Person
② 方式2：{}
1
2
var person = Person{}
person1 := Person{}
③ 方式3：&
1
2
3
4
5
6
7
8
9
10
var p3 *Person = new(Person)    // 这种方式为结构体指针

// 因为p3是一个指针，因此标准的给字段赋值方式
(*p3).Name = "smith"
// 但也可以这样写 
p3.Name = "smith"

// 原因：Go的设计者为了程序员使用方便，底层会对 p3.Name = "smith" 进行处理，会给p3加上取值运算 (*p3).Name = "smith"
(*p3).Age = 30
p3.Age = 100
④ 方式4：{}
1
2
3
4
5
6
7
var person *Person = &Person{"mary", 60, ...}    // 这种方式为结构体指针

// 因为person是一个指针，因此标准的访问字段的方法
(*person).Name = "scott"
// 同上，也可以
person.Name = "scott"