在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 bonecat.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) //Lianep1.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) //提醒谬误，持续编译后会打印undefinedconsole.log(a0.fun()) //提醒谬误，编译后会报错console.log(A.n) //0A.n = 100console.log(A.n) //100A.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 bonedog1.sayHi() //Hi,I am Jack