类

class Person{
    name:string;
  age:number;
  constructor(name: string, age:number)    {
    this.name = name;
    this.age = age;
  }
  print() {
    return this.name + ':' + this.age;
  }
}
const p = new Person('Tom', 30);
p.print(); // Tom: 30

继承

class Amy {
    sayAge(age: number = 0) {
      console.log(`Amy age is ${age}`);
  }
}
class Ami extends Amy {
    sayLastName(){
      console.log('Vernon');
  }
}
const ami = new Ami();
ami.sayLastName(); // Vernon
ami.sayAge(20); // Amy age is 30

修饰符

class Person {
    public name: string;
  private sex: string;
  protected age: number;
  constructor(name: string, sex: string, age:number){
      this.name = name;
    this.sex = sex;
    this.age = age;
  }
}
class Tom extends Person {
    constructor(name: string, sex: string, age: number){
      super(name, sex, age);
  }
  changeAge() {
    this.age = 40;
  }
  logSex() {
      console.log(this.sex);
  }
}
new Person('Tom', 'man', 30).name; //公有属性可以访问 -> tom
new Person('Tom', 'man', 30).sex; // 私有属性 不允许在外部访问
const t = new Tom('Tom', 'man', 30);
t.changeAge(); //受保护的属性 不允许被修改
t.logSex(); // 私有属性，不允许除自己类外的访问
class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor (theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus("name");
dad.name = "new name"; // 错误! name 是只读的.

public共有属性，可以随意访问。
private私有属性，只有自己的类可以访问。
protected受保护的属性，在类和子类中可以访问，其他地方无法访问。
readonly只读属性，只能读取。

存取器(拦截器)

class Person {
    private name: string;
  get name(): string {
      return this.name;
  }
  set name(newName: string) {
      if (newName && newName == "new name") {
        this.name = newName;
    } else {
        console.log("Error: The new name doesn't conform to the rules");
    }
  }
}
const p = new Person();
P.name = 'old name'; // 报错咯~

静态属性

class Person {
    static age = 30;
  say() {
      console.log(this.age);
  }
}
console.log(Person.age); // 30;
const p = new Person();
console.log(p.age()); // 错误 静态属性只能有类名调用
p.say(); // 错误 静态属性只能有类名调用

抽象类

抽象类是作为其他子类的基类，一般是不会被实例化，用abstract定义抽象方法 和抽象类。定义得抽象方法，子类必须实现,也可以由自身实现。

abstract class Person {
    abstract say():void;
  abstract tell(name: string): void{
      console.log(`hello ${name}`);
  }
}
class Man extends Person {
  say(): void {
      console.log(`抽象类定义的，子类必须实现`);
  }
}