在js中，类（Class）定义了一件事物的形象特点，蕴含它的属性和办法。对象（Object）为类的实例，能够通过new关键字生成。
面向对象的三大个性：封装，继承，多态
封装：将对数据的操作细节暗藏起来，只裸露对外的接口。通过对外提供的接口来拜访该对象，同时也保障外界无奈任意更改对象外部的数据。
继承：子类继承父类，子类除了领有父类的所有个性外，还有一些更具体的个性
多态：由继承而产生了相干的不同的类，对同一个办法能够有不同的响应。
存取器(getter&setter):用以扭转属性的读取和赋值行为。
修饰符：一些用于限定成员或类型的性质的关键字。例如public
- TypeScript中类的用法：
class Person{
name: string
age:number
gender:string
constructor(name:string='Liane',age:number=18,gender:string='female'){
this.name = name
this.age = age
this.gender = gender
}
sayHi(str:string){
console.log(`Hi ${str}, My name is ${this.name}, I'm ${this.age} years old`)
}
}
let p0 = new Person()
p0.sayHi('Ann')-
继承：
应用extends关键字，让子类继承自父类，应用super关键字调用父类的构造函数和实例办法，继承父类的属性和办法
class Students extends Person{ constructor(name: string, age:number,gender:string){ super(name,age,gender) } sayHi(str){ super.sayHi(str) } } let s0 = new Students('Jack',16,'man'); s0.sayHi('Liane') - 多态：
由继承而产生了相干的不同的类，对同一个办法能够有不同的响应。
class Animal{
name: string
constructor(name: string){
this.name = name
}
eat(str:string){
console.log(`${this.name} like to eat ${str}`)
}
}
class Dog extends Animal{
constructor(name:string='Tom'){
super(name)
}
eat(str){
super.eat(str)
}
}
class Cat extends Animal{
constructor(name:string='Jerry'){
super(name)
}
eat(str:string){
super.eat(str)
}
}
let dog = new Dog()
let cat = new Cat()
dog.eat('bone') //Tom like to eat bone
cat.eat('fish') //Jerry like to eat fish即Dog和Cat都继承自Animal，但别离实现了本人的eat办法。
- 类中的成员修饰符
用来形容类中的属性、构造函数和办法的可拜访性
public:默认修饰符，代表是公共的，在任何地位都能够被拜访。
private:公有修饰符，内部和子类都无法访问这个成员。
当心愿有的成员无奈直接存取时，可应用private修饰符润饰该成员。
应用private润饰constructor时，该类不容许被继承或者实例化。
protected:该修饰符润饰的成员，只能在其外部及子类中被拜访
应用protected润饰constructor时，该类只容许被继承，不容许实例化。
注：仅在TS编译时提醒谬误，在编译成js后，并没有限度private属性在内部的可拜访性或protected润饰构造函数的可实例化性。
-
readonly修饰符
润饰类中的属性成员，被润饰的属性不能在内部或类中的一般办法中被随便批改。能够在构造函数constructor中被批改。//readonly润饰类中的属性 class Person{ readonly name:string='jack' //可设置默认值 constructor(name:string){ this.name = name //能够在构造函数中批改name } sayHi(){ this.name = 'Hello' //提醒谬误 } } let p = new Person('Liane')//容许实例化传入新的name值 p.name = 'Ann' //提醒谬误 console.log(p.name) //Ann--即便提醒谬误，但若持续编译，编译后的js仍然不会限度批改readonly润饰的属性应用readonly润饰constructor的参数时，被润饰的参数称为参数属性
class Person{ constructor(readonly name:string){ this.name = name } } let p1 = new Person('Liane') consoel.log(p1.name) //Liane p1.name = 'Jack' //提醒谬误 //咱们发现，在cosntructor的参数前加上修饰符readonly，则该类中会主动增加一个被readonly润饰的属性成员，类比不难发现，结构函数参数应用public,private,protected与应用readonly统一。构造函数中的参数能够应用readonly进行润饰，一旦润饰，则该类中就有了这个只读参数的成员属性，内部能够拜访，但不能批改。
同理，构造函数中的参数能够应用public,private和protected进行润饰，无论是哪个修饰符，该类中都会主动增加一个被该修饰符润饰的属性成员。 -
存取器
让咱们能够无效的管制对对象中的成员的拜访和批改。通过getter和setter来进行操作。class Person{ firstName: string lastName: string constructor(firstName:string,lastName:string){ this.firstName = firstName this.lastName = lastName } get fullName(){ return this.firstName + '_' +this.lastName } set fullName(value){ const names = value.split('_') this.firstName = names[0] this.lastName = names[1] } } let p = new Person('诸葛','孔明') console.log(p.fullName) //诸葛_孔明 p.fullName = '司马_相如' console.log(p.firstName) //司马 -
动态成员
在类中通过static润饰的属性或办法，称为动态属性和静态方法，也称为动态成员。动态成员不会被实例继承，但能够被子类继承。
动态成员应用时通过类名.xxx的语法来调用class A{ static n:number = 0 static fun(){ A.n++ console.log(A.n) } } let a0 = new A() console.log(a0.n) //提醒谬误，持续编译后会打印undefined console.log(a0.fun()) //提醒谬误，编译后会报错 console.log(A.n) //0 A.n = 100 console.log(A.n) //100 A.fun() //101 -
抽象类
抽象类：蕴含形象办法(形象办法个别没有任何具体内容的实现)，也能够蕴含实例办法，抽象类是不能被实例化的，为了让子类进行实例化及实现外部的形象办法。
应用abstract定义一个抽象类和其中的形象办法。//定义一个抽象类 abstract class Animal1{ name:string age: number constructor(name:string,age:number){ this.name = name this.age = age } abstract eat(str) //定义一个形象办法，形象办法不容许具备任何内容 sayHi(){ //抽象类能够蕴含实例办法 console.log(`Hi,I am ${this.name}`) } } //定义一个子类继承自抽象类 class Dog1 extends Animal1{ eat(str){ //必须定义形象办法的实例办法，否则报错 console.log(`${this.name} like to eat ${str}`) } } let dog0 = new Animal1('Jack') //报错 let dog1 = new Dog1('Jack',2) dog1.eat('bone') //Jack like to eat bone dog1.sayHi() //Hi,I am Jack
发表回复