类

定义类

class 类名{
  	//定义实例属性，必须实例化才会有的属性
	属性名：类型=值
  	//加 static 定义静态属性，无需实例化就有的属性
  	static 属性名:类型=值
  	// readonly 只读的属性，无法修改
  	static readonly 属性名:类型=值
  	//定义方法，直接写就是实例方法，必须实例才可以调用
  	方法名(){
    	...
    }
   	//前边加static 定义的方法是静态方法，无需实例化就可以使用
   	static 方法名(){
    	...
    }
}

构造函数和this

class Dog{
  //构造函数会在对象创建时调用
  constructor(参数:类型){
  	this.name=参数
  }
}

继承

//继承 extends 父类
class Father{
  	sayHi(){
    }
}
//使用继承后，子类将会拥有父类所有的属性和方法
//通过继承可以将多个类***有的代码写在一个父类中，能供简化代码，提高复用性
//如果在子类中，添加了和父类相同的方法，则子类的方***覆盖父类的方法（方法重写）
class Son extends Father{
	sayHi(){
    }
}
  

super关键字

class Son extends Father{
	age:number
  	constructor(name:string,age:number){
    	//如果在子类中写了构造函数，在子类构造函数中必须对父类构造函数继承
      	super(name)
      this.age=age
    }
  	sayHi(){
    //在类的方法中super就表示当前类的父类
      	super.sayHi()
    }
}

抽象类

//以abstract开头的类是抽象类，抽象类和其他类区别不大，只是不能用来创建对象，是专门用来被继承的类
abstract class Father{
	name:string
  constructor(name:string){
  	this.name=name
  }
  //定义抽象方法使用abstract开头，没有方法体，抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
  abstract sayHi():void 
}

接口

//接口用来定义一个类结构,用来定义一个类中应该包含哪些属性和方法
//接口也可以当成类型声明来使用
interface myInterface{
	name:string
  	age:number
}
//定义两个重名的接口，可以合并为一个使用
interface myInterface{
	gender:string
}
const obj:myInterface{
	name:'刘成'
  	age:12
  	gender:'男'
}
//接口可以在定义类的时候去限制类的结构
//接口只定义对象的结构而不考虑实际值，在接口中所有的方法都是抽象方法
interface myInter{
	name:string
  	sayHello():void;
}
//定义类时，可以使类去实现一个接口，实现接口就是使类满足接口的要求
class MyClass implements myInter{
	name:string
  	sayHello(){
    	console.log('Hello!)
    }
}

属性的封装

class Person{
	//设置私有属性，外部不能访问和修改
  	private _age:number
  	constructor(age:number){
    	this._age=age
    }
  //定义方法，用来获取age属性
  	getAge(){
    	return this._age
    }
  //定义方法，用来修改age属性
  	steAge(value:number){
    	this._age=value
    }
  //getter方法用来读取属性，setter方法用来设置属性，他们被称为属性的存取器
  //TS中设置getter方法的方式
  get age(){
  	return this._age
  }
  //TS中设置setter方法的方式
  set age(value:number){
  	this._age=value
  }
}
class C{
	//可以直接将属性定义在构造函数中
  	constructor(public name:string,public age:number){
    }
}

泛型

//在定义函数或者类的时候，如果遇到类型不明确就可以使用泛型
function fn<T>(a:T):T{
	return a
}
//可以直接调用具有泛型的函数
let result = fn(a:10)//不指定泛型，TS可以自动对类型进行判断
let result2 = fn<string>(a:'hello')//指定泛型
interface Inter{
	length:number
}
//T extends Inter 表示泛型T必须是Inter实现类（子类）
function fn2<T extends Inter>(a:T):number{
	return a.length
}
fn2(a:{length:10})
//泛型也可以在类中使用
class MyClass<T>{
	name:T
  	constructor(name:T){
    	this.name=name
    }
}
const mc=new MyClass<string>(name:'刘成')