与C++中的Class类似。但是不存在私有成员。
this指向类的实例。

定义

  1. class Point {
  2.     constructor(x, y) {  // 构造函数
  3.         this.x = x;  // 成员变量
  4.         this.y = y;
  6.         this.init();
  7.     }
  9.     init() {
  10.         this.sum = this.x + this.y;  // 成员变量可以在任意的成员函数中定义
  11.     }
  13.     toString() {  // 成员函数
  14.         return '(' + this.x + ', ' + this.y + ')';
  15.     }
  16. }
  18. let p = new Point(3, 4);
  19. console.log(p.toString());

继承

  1. class ColorPoint extends Point {
  2.     constructor(x, y, color) {
  3.         super(x, y); // 这里的super表示父类的构造函数
  4.         this.color = color;
  5.     }
  7.     toString() {
  8.         return this.color + ' ' + super.toString(); // 调用父类的toString()
  9.     }
  10. }

注意：

  • super这个关键字，既可以当作函数使用，也可以当作对象使用。
  • 作为函数调用时，代表父类的构造函数，且只能用在子类的构造函数之中。
  • super作为对象时，指向父类的原型对象。
  • 在子类的构造函数中，只有调用super之后，才可以使用this关键字。
  • 成员重名时，子类的成员会覆盖父类的成员。类似于C++中的多态。

静态方法

在成员函数前添加static关键字即可。
父类的静态方法可以被子类调用。
子类可以重写父类的静态方法。
静态方法不会被类的实例继承，只能通过类来调用。例如：

  1. class Point {
  2.     constructor(x, y) {
  3.         this.x = x;
  4.         this.y = y;
  5.     }
  7.     toString() {
  8.         return '(' + this.x + ', ' + this.y + ')';
  9.     }
  11.     static print_class_name() {
  12.         console.log("Point");
  13.     }
  14. }
  16. let p = new Point(1, 2);
  17. Point.print_class_name();
  18. p.print_class_name();  // 会报错

静态变量

在ES6中，只能通过class.propname定义和访问。例如：
子类可以继承父类的静态变量。
子类可以重写父类的静态变量。

  1. class Point {
  2.     constructor(x, y) {
  3.         this.x = x;
  4.         this.y = y;
  6.         Point.cnt++;
  7.     }
  9.     toString() {
  10.         return '(' + this.x + ', ' + this.y + ')';
  11.     }
  12. }
  14. Point.cnt = 0;
  16. let p = new Point(1, 2);
  17. let q = new Point(3, 4);
  19. console.log(Point.cnt);