一：类的访问类型
    1、public，在类内和类外均可调用。

    1. class Person {
    2.   name: string;
    3.     // 相当于 public name: string
    4.     public sayHello(){
    5.     console.log(this.name + ' say Hello')
    6.   }
    7. }
    9. // 类外
    10. const person = new Person();
    11. person.name = "jspang.com";

    2、private，只允许在类内部使用，不可在类外部使用。

    1. class Person {
    2.     private name:string;
    3.     public sayHello(){
    4.         console.log(this.name + 'say Hello')  //此处不报错
    5.     }
    6. }
    7. // 类外
    8. const person = new Person()
    9. person.name = 'jspang.com'    //此处报错
    10. person.sayHello()
    11. console.log(person.name)  //此处报错

    3、protected，允许在类内或继承的子类使用。

    1. class Person {
    2.     protected name:string;
    3.     public sayHello(){
    4.         console.log(this.name + 'say Hello')  //此处不报错
    5.     }
    6. }
    8. class Teacher extends Person{
    9.     public sayBye(){
    10.         console.log(this.name); // 不报错
    11.     }
    12. }

    二：类的构造函数

    1. class Person{
    2.     public name :string ;
    3.     constructor(name:string){
    4.         this.name=name
    5.     }
    7.         // 相当于
    8.         constructor(public name:string) { }
    9. }
    11. const person= new Person('jspang')
    12. console.log(person.name)

    在子类中使用构造函数需要用super()调用父类的构造函数：

    1. class Person{
    2.     constructor(public name:string){}
    3. }
    4. class Teacher extends Person{
    5.     constructor(public age:number){
    6.         super('jspang')
    7.     }
    8. }
    9. const teacher = new Teacher(18)
    10. console.log(teacher.age)
    11. console.log(teacher.name)
    13. // 如果父类没有构造函数，也需要调用super。
    14. class Person{}
    15. class Teacher extends Person{
    16.     constructor(public age:number){
    17.         super()
    18.     }
    19. }
    20. const teacher = new Teacher(18)
    21. console.log(teacher.age)

    三：类的getter、setter、static和readonly
    1、getter，可以用于暴露类内的private属性和加一层处理。
    2、setter，在设置属性时，处理传进来的参数。

    1. class Xiaojiejie {
    2.   constructor(private _age:number){}
    3.   get age(){
    4.       return this._age-10
    5.   }
    6.   set age(age:number){
    7.     this._age = age+3
    8.   }
    9. }
    11. const dajiao = new Xiaojiejie(28)
    12. dajiao.age=25
    13. console.log(dajiao.age)

    3、static，不需要实例化类就可以取得类的属性和方法。

    1. class Girl {
    2.   static sayLove() {
    3.     return "I Love you";
    4.   }
    5. }
    6. console.log(Girl.sayLove());

    4、readonly，只读属性。

    1. class Person {
    2.     public readonly _name :string;
    3.     constructor(name:string ){
    4.         this._name = name;
    5.     }
    6. }
    8. const person = new Person('jspang')
    9. person._name= '谢广坤' // 报错
    10. console.log(person._name)

    四：抽象类，要求继承的子类必须声明某些属性或方法。
    比如我开了一个红浪漫洗浴中心，里边有服务员，有初级技师，高级技师，每一个岗位我都写成一个类。我作为老板，我要求无论是什么职位，都要有独特的技能，比如服务员就是给顾客倒水，初级技师要求会泰式按摩，高级技师要求会 SPA 全身按摩。这是一个硬性要求，但是每个职位的技能有不同，这时候就可以用抽象类来解决问题。

    1. abstract class Girl{
    2.     abstract skill()  //因为没有具体的方法，所以我们这里不写括号
    3. }
    5. class Waiter extends Girl{
    6.     skill(){
    7.         console.log('大爷，请喝水！')
    8.     }
    9. }
    10. class BaseTeacher extends Girl{
    11.     skill(){
    12.         console.log('大爷，来个泰式按摩吧！')
    13.     }
    14. }
    15. class seniorTeacher extends Girl{
    16.     skill(){
    17.         console.log('大爷，来个SPA全身按摩吧！')
    18.     }
    19. }