定义

类声明

使用带有class关键字的类名

提升
函数声明会提升，类声明不会。你首先需要声明你的类，然后访问它，否则像下面的代码会抛出一个 ReferenceError：

1
2
3
let p = new Rectangle(); // ReferenceError

class Rectangle {}

类表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 匿名类
let Rectangle = class {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
};
console.log(Rectangle.name);
// output: "Rectangle"

// 具名类
let Rectangle = class Rectangle2 {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
};
console.log(Rectangle.name);
// 输出: "Rectangle2"

constructor

constructor是一种用于创建和初始化class创建的对象的特殊方法。

如果没有显式指定构造方法，则会添加默认的constructor方法。

如果不指定一个构造函数(constructor)方法, 则使用一个默认的构造函数(constructor)。

1
2
3
4
5
6
7
8
9
10
class Polygon {
  constructor() {
    this.name = "Polygon";
  }
}

const poly1 = new Polygon();

console.log(poly1.name);
// expected output: "Polygon"

super

super关键字用于访问和调用一个对象的父对象上的函数。

1
2
3
4
5
super([arguments]); 
// 调用 父对象/父类 的构造函数

super.functionOnParent([arguments]); 
// 调用 父对象/父类 上的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Polygon {
    constructor(height, width) {
        this.name = 'Rectangle';
        this.height = height;
        this.width = width;
    }
    
    static sayHello() {
        console.log('HI, I am a ' + this.name + '.');
    }
}

class Square extends Polygon {
    constructor(length, length1) {
        // 调用父构造函数
        super(length, length1);
        this.name = 'Square';
    }
    
    static logDesc() {
        // 调用父构造函数中的 *静态方法*
        return super.sayHello()
    }
}

const A = new Square(10,20);

static

通过static关键字定义静态方法。不能在类的实例上调用静态方法，而应该通过类本身调用。这些通常是实用程序方法，例如创建或克隆对象的功能。

1
2
3
4
5
6
7
class ClassWithStaticMethod {
  static staticMethod() {
    return 'static method has been called.';
  }
}

console.log(ClassWithStaticMethod.staticMethod());

extends

extends关键字用于类声明或者类表达式中，以创建一个类，该类是另一个类的子类。