TypeScript 除了实现了所有 ES6 中的类的功能以外，还添加了一些新的用法（部分ES7）。

一、ES6中类的主要用法：

1、使用 classconstructor 定义构造函数。通过 new 生成新实例的时候，会自动调用构造函数。

2、使用 extendssuper 关键字来调用父类的构造函数和方法。

3、使用 static 修饰符修饰的方法称为静态方法，它们不需要实例化，而是直接通过类来调用。

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  run = (): string => {
    // 实例方法
    return this.name;
  };
  static print = () => {
    console.log("Persion的静态方法");
  };
}
var p = new Person("testName");
p.run();
Person.print();

二、实现的ES7中类的用法：

1、ES6 中实例的属性只能通过构造函数中的 this.xxx 来定义，ES7 提案中可以直接在类里面定义

2、ES6 中只有静态方法，ES7 提案中，可以使用 static 定义静态属性

class Person {
  name: string;
  static title: string = "类的静态属性";
  constructor(name: string) {
    this.name = name;
  }
  run = (): string => {
    // 实例方法
    return this.name;
  };
  static print = () => {
    console.log("Persion的静态方法");
  };
}
var p = new Person("testName");
p.run();
Person.print();
console.log(Person.title);

三、TypeScript自身实现的类的用法：

1、TypeScript 新增了三种访问修饰符来修饰属性或方法，分别是 public、privateprotected。

  • public的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是 public 的。在类的里边、子类以及类的外边都可以访问
class Person {
  name: string; //定义属性  前面省略了public关键词
  constructor(n: string) {
    // 构造函数---实例化类的时候出发的方法
    this.name = n;
  }
  run = (): string => {
    return this.name;
  };
}
var p = new Person("testName");
console.log(26, p.name); // 可访问
console.log(p.run()); // 可调用
  • protected（保护）private在类里边和子类中可以访问，在类外部无法访问
class Person {
  protected name: string; //定义属性  前面省略了public关键词
  constructor(n: string) {
    // 构造函数---实例化类的时候出发的方法
    this.name = n;
  }
  run = (): string => {
    return this.name; // 可访问
  };
}
var p = new Person("testName");
console.log(p.run()); // 可调用

// 通过extends和super实现继承
class Web extends Person {
  constructor(name: string) {
    super(name);
    console.log(this.name); // 可访问
  }
}
const w = new Web("test");
// console.log(w.name) //不可访问
// console.log(p.name) // 不可访问
  • private在类里边可以访问，子类和类外部无法访问
class Person {
  private name: string; //定义属性  前面省略了public关键词
  constructor(name: string) {
    // 构造函数---实例化类的时候出发的方法
    this.name = name;
  }
  run = (): string => {
    return this.name; // 可访问
  };
}
var p = new Person("testName");

// 通过extends和super实现继承
class Web extends Person {
  constructor(name: string) {
    super(name);
    // console.log(this.name); // 可访问
  }
}
const w = new Web("test");
// console.log(w.name) //不可访问
// console.log(p.name) // 不可访问

2、readonly只读属性关键字，只允许出现在属性声明或索引签名中

3、abstract 用于定义抽象类和其中的抽象方法。抽象类是不允许被实例化的；抽象类中的抽象方法必须被子类实现，抽象方法只能放在抽象类中。抽象类和抽象方法用来定义标准,为子类提供一个基类

abstract class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  abstract eat(): string;
}

class Dog extends Animal {
  eat = () => {
    return "狗粮";
  };
}

let dog = new Dog("kittle");
console.log(dog.eat());