泛型
泛型是一种参数化数据类型，具有以下特点
1：定义时不明确，使用时必须明确成 某种具体数据类型 的数据类型【泛型的宽泛】
2：编译期间进行 数据类型安全检查 的数据类型【泛型的严谨】
泛型类的格式： class 类名<泛型形参类型>{ }
class ArrayList<T>{
array: Array<T>
add(data:T){
....
}
....
}
泛型形参类型一般有两种表示:
1、 A-Z 任何一个字母（绝大多数情况是这种）
2、 语义化的单词来表示
class ArrayList<T> {
public element: Array<T>;
constructor() {
this.element = [];
}
public index: number = 0;
public add(ele: T) {
this.element[this.index++] = ele;
}
get(index: number): T {
return this.element[index];
}
}
type stuType = { stuname: string; age: number; address: string };
let stuOne: stuType = { stuname: "wnagwu", age: 23, address: "beijing" };
let stuTwo: stuType = { stuname: "lisi", age: 39, address: "shanghai" };
let stuThree: stuType = { stuname: "liuqi", age: 31, address: "nanjing" };
let arrayList3 = new ArrayList<stuType>();
arrayList3.add(stuOne);
arrayList3.add(stuTwo);
arrayList3.add(stuThree);
let stuobj = arrayList3.get(1);
console.log(stuobj.stuname); //能点出来
//泛型如果在使用时没有具体化的类型,那么就会默认为unknown数据类型
//class ArrayList<T=any> {} //这样默认值就是any
//class ArrayList<T=number> {}
//这样默认值就是number,但下面的arrayList5.add("abc")就会报错
let arrayList5 = new ArrayList();
arrayList5.add(3);
arrayList5.add("abc");
arrayList5.add(stuOne);
arrayList5.get(2); //点不出来，类型“unknown”
泛型约束
泛型约束简单点说就是把泛型的具体化数据类型范围缩小
T extends object 表示具体化的泛型类型只能是 object 类型
泛型接口+ 泛型类 + 泛型约束 + 多态
//泛型接口 + 泛型类
interface List<T> {
add(ele: T): void;
get(index: number): T;
size(): number;
}
class ArrayList<T> implements List<T> {
public array: Array<T>;
public index: number = 0;
constructor() {
this.array = [];
}
public add(ele: T) {
this.array[this.index++] = ele;
}
size() {
return this.index ? this.index : 0;
}
get(index: number): T {
return this.array[index];
}
}
// 定义继承类（多态）
abstract class People {
public name!: string;
public abstract info(): void;
public eat() {
console.log("人类-吃饭");
}
}
class Man extends People {
public info() {
console.log("男人");
}
}
class Woman extends People {
public info() {
console.log("女人");
}
}
// 结合使用
class Tcs {
//泛型约束
public rent<T extends object>(list: List<T>) {
for (let i = 0; i < list.size(); i++) {
let res = list.get(i);
console.log("get拿到的类型是：", res);
//虽然传入前和get拿到的类型是一样的，外部可以点操作，这里不行。
//是因为谁知道你传入的泛型类是否一定有info()函数，所以需as断言后才能使用点
//或者泛型约束为People类型
(res as any).info(); //用了any自然不能点操作
}
}
}
//let aList: List<String> = new ArrayList<String>();
//泛型约束是为了防止，如上句，泛型为String则会影响Tcs类的内部代码使用
let aList: List<People> = new ArrayList<People>();
//上句：左边是List接口，右边是ArratList接口。同样是多态，接口的多态
let bus: People = new Woman(); //类的多态
console.log("传入前的类型是：", bus);
aList.add(bus);
aList.add(new Man()); //类的多态
let tc = new Tcs();
tc.rent(aList);
export {};
泛型函数：
格式： 函数名<泛型1,泛型2> (参数中可以使用泛型类型)：返回值也可以是泛型类型
泛型函数好处：可在调用返回后 得到返回值的具体数据类型，从而有点操作和类型错误的提示
let numArr: number[] = [1, 3, 5, 7];
let strArr: Array<string> = ["a", "c", "e", "g"];
// Array<T> 等于 T[]
function funa<T>(arr: Array<T>): T[] {
let newNumArr: Array<T> = [];
newNumArr.push(arr[0]);
return newNumArr;
}
console.log("funa1:", funa(numArr)); // [ 1 ]
console.log("funa2:", funa(strArr)); // [ 'a' ]
泛型函数+重载
function funb(data: string): string;
function funb<T>(data: T): T;
function funb(data: any): any {
if (typeof data === "string") {
return "字符串类型";
}
if (data instanceof Array) {
return funa(data);
}
}
console.log("funb1:", funb("abcde")); // 字符串类型
console.log("funb2:", funb(numArr)); // [ 1 ]
