2022-5-17 实习Day38

1、汇入汇款黑名单前台弹框无法关闭问题 – 3小时 80%

2、汇入汇款前端不返显问题排查 –2小时 100%

3、gpi299报文发送未接收排查 –2小时 80%

Golang编程学习（part 33）

1、面向对象编程 — 多态

① 基本介绍：变量（实例）具有多种形态。面向对象的第三大特征，在Go语言，多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态
② 接口体现多态的两种形式

1）多态参数：在前面的Usb接口案例，usb Usb，既可以接收手机变量，又可以接收相机变量，就体现了Usb接口的多态特点

2）多态数组：演示一个案例，给Usb数组中存放Phone结构体和Camera结构体变量

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
package main

import "fmt"

type Usb interface {
    charge()
}
type Phone struct {
    brand string
}

type Camera struct {
    brand string
}

func (p *Phone) charge() {
    fmt.Println("手机充电了")
}

func (c Camera) charge() {
    fmt.Println("照相机充电了")
}
func main() {
    arr := make([]Usb, 10)
    arr = append(append(arr, &Phone{"苹果"}), &Camera{"索尼"})
    fmt.Println(arr)
}

2、 类型断言

① 由一个具体的需要，引出类型断言（将接口变量赋给自定义变量）
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
package main
import "fmt"
type Point struct {
    x int
    y int
}

func main() {
    var a interface{}
    var point Point = Point{
        x: 1,
        y: 2,
	}
    a = point

    //如何将a付给一个Point变量
    var b Point
    // 报错
    // b=a
	
    // 这里使用了类型断言，就可以了
    b = a.(Point)
    fmt.Println(b)
}

b=a.(Point)就是类型断言，表示判断a是否指向Point类型的变量，如果是就转为Point类型并赋给b变量，否则报错（panic）

② 如何在进行断言时，带上检测机制，如果成功就ok，否则也不要报panic
1
2
3
4
5
6
7
8
9
10
11
12
13
var x interface{}
var b2 float32 = 2.1
x = b2  // 空接口，可以接收任意类型

// 类型断言（带检测的）
if y, ok := x.(float32); ok {
    fmt.Println("convert success")
    fmt.Printf("y 的类型是 %T , 值是=%v", y, y)
} else {
    fmt.Println("convert fail")
}

fmt.Println("继续执行")
③ 类型断言的最佳实践1

给Phone结构体增加一个特有的方法 call()，当Usb接口接受的是Phone变量时，还需要调用call方法

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package main
import (
    "fmt"
)

type Usb interface {
    Start()
    Stop()
}
type Phone struct {
    Name string
}

type Camera struct {
    Name string
}

func (c *Camera) Start() {
    fmt.Println(c.Name, "启动成功")
}

func (c *Camera) Stop() {
    fmt.Println(c.Name, "关闭成功")
}

func (p *Phone) Start() {
    fmt.Println(p.Name, "启动成功")
}

func (p *Phone) Stop() {
    fmt.Println(p.Name, "关闭成功")
}

type Computer struct {
    Name string
}

func (c Computer) Working(usb Usb) {
    usb.Start()

    //如果usb是指向Phone结构体变量，则还需要调用Call方法
    if v, ok := usb.(*Phone); ok {
        v.Call()
    }
    usb.Stop()
}

func (p *Phone) Call() {
    fmt.Println(p.Name, "打电话了")
}

func main() {
    // 定义一个Usb接口数组，可以存放Phone和Camera的结构体变量
    // 这里就体现出多态数组
    var usb [3]Usb
    usb[0] = &Phone{"vivo"}
    usb[1] = &Phone{"小米"}
    usb[2] = &Camera{"尼康"}
    var computer Computer
    for _, j := range usb {
        computer.Working(j)
        fmt.Println()
    }
}

vivo 启动成功
vivo 打电话了
vivo 关闭成功

小米 启动成功
小米 打电话了
小米 关闭成功

尼康 启动成功
尼康 关闭成功

④ 类型断言的最佳实践2

写一函数，循环判断传入参数的类型

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
package main
import "fmt"
// 编写一个函数，可以判断输入的参数是什么类型
func TypeJudge(items ...interface{}) {
    for index, x := range items {
        switch x.(type) {
        case bool:
            fmt.Printf("第%v个参数是 bool 类型, 值是%v \n", index, x)
        case float32:
            fmt.Printf("第%v个参数是 float32 类型, 值是%v \n", index, x)
        case float64:
            fmt.Printf("第%v个参数是 float64 类型, 值是%v \n", index, x)
        case int, int32, int64:
            fmt.Printf("第%v个参数是 整数 类型, 值是%v \n", index, x)
        case string:
            fmt.Printf("第%v个参数是 string 类型, 值是%v \n", index, x)
        case Student:
            fmt.Printf("第%v个参数是 Student 类型, 值是%v \n", index, x)
        case *Student:
			fmt.Printf("第%v个参数是 *Student 类型, 值是%v \n", index, x)                 
        default:
            fmt.Printf("第%v个参数是 类型 不确定, 值是%v \n", index, x)
        }
    }
}
func main() {
    TypeJudge(20, 20.0, "123", true)     
}

第0个参数是 整数 类型, 值是20
第1个参数是 float64 类型, 值是20 
第2个参数是 string 类型, 值是123 
第3个参数是 bool 类型, 值是true