Go语言面向对象编程

---

构造函数

单例模式

单例模式为了防止多线程下冲突，需要sync.Once保证原子性。

---

结构体组合

package main

import "fmt"

type Plane struct {
	Color string
	name string
}

func (Plane) fly() int {
	return 500
}

type Car struct {
	speed int
}

func (car Car) run() {
	fmt.Printf("run at %d km/h\n", car.speed)
}

type Bird struct {
	Name string
	Plane
	Car
}

func (bird Bird) fly() int {
	return 1000
}
func main() {
	bird := Bird{Name: "鸟", Plane: struct{ Color string
		name string}{Color: "红",name:"123"}, 
		Car: struct{ speed int }{speed: 10}}

	bird.run()
	fmt.Println(bird.Color, bird.speed)
	bird.speed = bird.fly() //调用bird重写后的fly
	bird.run()
	bird.speed = bird.Plane.fly() //显示调用，调用的是plane的fly
	bird.run()

}
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

结构体组合，在创建对象时赋值，需要先指定组合结构体的内部类型：

---

泛型

go泛型使用方法
泛型类似于C++中的模板。旨在为程序员生成代码，减少重复代码的编写。

// 使用泛型
func add[T int | int8 | float32](a, b T) T {
	return a + b
}

func main() {
	a := 4
	b := 7
	var c, d float32 = 4.0, 4.1
	fmt.Println(add(a, b))
	fmt.Println(add(c, d))
	//fmt.Println(add1[int, float32](a, d))
}
1
2
3
4
5
6
7
8
9
10
11
12
13

如果类型太多,这时候我们就可以自定义泛型类型：

//像接口一样声明泛型的类型
type Addable interface {
	int | float32 | string
}
//指定泛型的类型
func add1[T Addable](a, b T) T {
	return a + b
}

func add2[T1 Addable, T2 Addable](a T1, b T2) int {
	return 1
}
func main() {
	a := 4
	b := 7
	var c, d float32 = 4.0, 4.1
	fmt.Println(add(a, b))
	fmt.Println(add(c, d))
	fmt.Println(add2(a, d))
	//显示地指定泛型类型
	fmt.Println(add2[int, float32](a, d))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22