类
ts中定义类，需要用到class关键字
constructor是一个构造函数，实例化类的时候会触发的方法
class aClass{
name: string;
constructor(name: string){
this.name=name
}
getName ():string {
return this.name;
}
}
继承
可以使用extends和super关键字实现继承 子类继承父类：
class Child extends Person {
constructor (name:string) {
super(name); // 初始化父类的构造函数
}
}
父类的方法和子类的方法一致，子类可以调用父类的方法，如果子类会执行子类自己的方法，就是重写父类的方法。
修饰符
ts中有三种修饰符：
- public：公有，在当前类里面、子类、类外面都可以访问
- protected：保护类型，在当前类里面、子类里面可以访问，在类外部没法访问
- private：私有，在当前类里面可以访问，子类、类外部都没法访问 属性如果不加修饰符，默认就是公有（public）
和java不同的是，ts的默认值是public
继承和多态
- 继承子类继承父类，子类除了拥有父类的所有特性外，还有一些具体的特性
- 多态由继承而产生了相关的不同的类，对同一个方法可以有不同的行为
抽象类
使用abstract关键字
- 抽象类中不能实现抽象方法，必须在子类中实现（并且子类中必须实现）
- 抽象方法只能写在抽象类中
abstract class Animal{
name:string;
abstract action():void
}
class Bird extends Animal{
action(){
console.log('fly')
}
}
泛型
创建一个可重用性的API，不仅需要满足当前的数据类型，还要考虑将来需要使用的数据类型。一个组件可以支持多种类型的数据，可以使用泛型来实现。
要求接受string类型/number类型的数据，返回string类型/number类型的数据。
function method1(val: string):string{
return val;
}
function method2(val: number):number{
return val;
}
如果这样写需要写两遍函数，比较麻烦，可以使用any关键字 但是又不能实现输入什么类型就返回什么类型：
function method3(val: any):any{
return val;
}
可以使用泛型：T表示泛型，具体什么类型是在调用这个方法的时候决定的
function method4(val: T):T{
return val;
}
泛型类
如果需要写一个类，可以实现排序数字或排序字母，并且返回最小值。
直接写需要写两个类：一个传入number类型并排序，然后返回number类型，另一个传入string类型并排序，然后返回string类型。
正常的类只能实现一种类型。可以考虑用泛型解决，支持 number 和 string：
class returnMininClass {
list:T[] = [];
add (val:T):void {
this.list.push(val);
}
min ():T {
let minNum:number = this.list[0];
for(let i = 0; i < this.list.length; i++) {
if(minNum > this.list[i]){
minNum = this.list[i];
}
}
return minNum;
}
}
let m = new minClass();
m.add(3);
m.add(2);
m.add(23);
console.log(m.min()); // 2
在使用的时候，先初始化这个泛型类，然后使用：
let m1 = new minClass<number>(); // 实例化类，指定了类的 T 代表的类型是 number
m1.add(3);
m1.add(2);
m1.add(23);
console.log(m1.min()); // 返回2
let m2 = new minClass<string>(); // 实例化类，指定了类的 T 代表的类型是 string
m2.add('a');
m2.add('d');
m2.add('f');
console.log(m2.min());// 返回a
