day16 泛型

了解泛型

• 1.18后引入泛型（类型参数）
• 用户传入参数类型
• 场景使用很少
• 1.18以前使用 [反射] 来处理不同参数类型的问题
• 泛型也是使用 [] 和数组很像！ 即：[T any]泛型的约束
• 泛型的作用：减少代码重复型，只针对不同类型相同功能的代码
• 泛型的类型：多个类型（类型不确定）
• 把静态语言 转换成 动态语言

泛型的类型

• T 就是一个占位符。 类型的形式参数，T是不确定的，需要在使用时传递类型
• 由于T的类型是不确定的，需要增加一下约束 int｜float32｜float64｜string

package main

import "fmt"

type s1 []int

// Slice 定义泛型切片类型, 类型参数化
/*
	- T 就是一个占位符。 类型的形式参数，T是不确定的，需要在使用时传递类型
	- 由于T的类型是不确定的，需要增加一下约束 int｜float32｜float64｜string
*/
type Slice[T int | float64] []T

func main() {
	/* 泛型的类型 */
	var a s1 = []int{1, 2, 3}
	fmt.Println(a)

	// 使用泛型创建变量。 泛型就是将数据语言有静态变为动态类型
	var b Slice[int] = []int{1, 2, 3}
	fmt.Printf("%T\n", b) // main.Slice[int]
	var c Slice[float64] = []float64{1.1, 2.2, 3.3}
	fmt.Printf("%T\n", c) // main.Slice[float64]
	fmt.Println("泛型：", b, c)
}

泛型使用

• 泛型的参数类型的属性。不止一个，所有东西都可以泛型化

package main

import "fmt"

type MyStruct[T int | string] struct {
	id   T // 多类型
	Name string
	sex  bool
}
type MyInterface[T string | int | float64] interface {
	Print1(data string)
	Print2(data T)
}
type MyChan[T string | int] chan T

func main() {
	/* T 泛型的参数类型的属性。不止一个，所有东西都可以泛型化 */

	// 1. 泛型化 map  GenericsMap[T,T]
	type GenericsMap[K string | int | float64, V string | int | float64] map[K]V

	// 1.1 实例化泛型 map
	var score1 GenericsMap[string, int] = map[string]int{
		"a": 100,
		"b": 200,
		"c": 300,
	}
	fmt.Printf("score1=%v\n", score1)

	var score2 GenericsMap[int, int] = map[int]int{
		1: 100,
		2: 200,
		3: 300,
	}
	fmt.Printf("score2=%v\n", score2)

	// 2. 泛型化 slice genericsSlice[T]
	type genericsSlice[T string | int | float64 | float32] []T

	// 3. 结构体 泛型 MyStruct
	var genericsStruct1 MyStruct[int] = MyStruct[int]{10, "张三", true}
	fmt.Printf("genericsStruct1=%v\n", genericsStruct1)
	var genericsStruct2 MyStruct[string] = MyStruct[string]{"我不是", "张三", true}
	fmt.Printf("genericsStruct2=%v\n", genericsStruct2)

	// 4. 接口泛型
	//MyInterface()

	// 5. 通道
	//MyChan

}

特殊的泛型

package main

import "fmt"

func main() {
	/* 特殊的泛型:一般不会使用*/

	type MyGenericsInt[T string | int] = int // 结果一定是整型
	var a1 MyGenericsInt[string] = 1
	var b1 MyGenericsInt[int] = 2
	fmt.Println(a1, b1)
	//var c1 MyGenericsInt[string] = "1234" // 因为底层类型设定的是 int。 传入泛型的类型任意，但是结果必须是int，即：赋值时结果是整型
}

泛型函数

package main

import "fmt"

// MySumSlice 定义泛型类型
type MySumSlice[T string | int | float64 | float32] []T

// MySumSlice 函数调用者泛型化
func (s MySumSlice[T]) sum(s1 int) T {
	fmt.Printf("Sum s1: %d\n", s1)
	var sum T
	for _, v := range s {
		sum += v
	}
	return sum
}

// Add 参数泛型化
func Add[T string | int | float64 | float32](a T, b T) T {
	return a + b
}
func main() {
	/*
		泛型函数
			- 1 调用者不同，传入泛型类型。
			- 2.普通函数，即：参数泛型化
	*/

	// 1. 调用者不同。 引入泛型化的数据类型调用函数
	var intSlice MySumSlice[int] = []int{1, 2, 3, 4, 5}
	intRes := intSlice.sum(1235456)
	fmt.Println("intRes:", intRes)
	var float32Slice MySumSlice[float32] = []float32{1.2, 2.2, 3, 4, 5}
	float32Res := float32Slice.sum(222)
	fmt.Println("float32Res:", float32Res)

	// 2. 函数参数泛型化，同类型参数支持自动推到 ADD(int,int)
	var ia int = 1
	var ib int = 1
	addRes1 := Add[int](ia, ib)
	fmt.Println("addRes1:", addRes1)
	var fa float32 = 12.33
	var fb float32 = 1.235 // 遵循四舍五入
	addRes2 := Add[float32](fa, fb)
	fmt.Println("addRes2:", addRes2)
	var sa string = "abc"
	var sb string = "xyz"
	addRes3 := Add[string](sa, sb)
	fmt.Println("addRes3:", addRes3)

}

自定义泛型

package main

import "fmt"

type genericsInterface interface {
	string | int | float64 | float32 | int8 | int16 | int32
}

func getMax[T genericsInterface](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	/* 自定义泛型 */
	var a = 10
	var b = 20
	fmt.Println(getMax(a, b))
	var c = "10"
	var d = "20"
	fmt.Println(getMax(c, d))
}

内置泛型

package main

import "fmt"

// int8 衍生类型
type int8AT int8 // int8AT 就是 int8 的衍生类型
type int8BT int8 // intB 就是 int8 的衍生类型

// MyGenerics01 自定义 泛型类型 接口. ~表示可以匹配该类型的衍生类型
type MyGenerics01 interface {
	~int8
}

func compareTheSize[T MyGenerics01](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	/*
		内置泛型
			- any  就是一个泛型，内置类型。interface{}
			- comparable 表示比较所有的类型
			- 新符号 （~）衍生类型
	*/

	// ~ 新符号使用
	var a1 int8AT = 3
	var b1 int8AT = 5
	fmt.Println(a1, b1)
	fmt.Printf("%T\n", a1) // main.int8AT
	fmt.Printf("%T\n", b1) // main.int8BT
	//fmt.Println(compareTheSize(a1, b1))
	fmt.Println(compareTheSize(b1, a1))
}