共计 3631 个字符，预计需要花费 10 分钟才能阅读完成。
在 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
