在class
中继承主要是依靠两个东西:
extends
super
而且对于该继承的效果和寄生组合继承方式一样。
继承规则
class Parent {
}
class Child extends Parent {
}
上面代码定义了一个Child
类,该类通过extends
关键字,继承了Parent
类的所有属性和方法。但是由于没有部署任何代码,所以这两个类完全一样,等于复制了一个Point
类。
如果想在子类中添加属性与方法,就可以:
class Parent {
constructor(name, sex) {
this.name = name
this.sex = sex
}
sing() {
console.log(this.sex);
}
}
class Child extends Parent {
constructor(name, sex, num) {
super(name, sex) // 调用父类的constructor(x, y)
this.num = num
}
song() {
console.log(this.name);
}
}
constructor
子类必须在constructor
方法中调用super
方法
- 子类必须在
constructor
方法中调用super
方法,否则新建实例时会报错。这是因为子类自己的this
对象,必须先通过父类的构造函数完成塑造,得到与父类同样的实例属性和方法,然后再对其进行加工,加上子类自己的实例属性和方法。如果不调用super
方法,子类就得不到this
对象。
class Parent { /* ... */ }
class Child extends Point {
constructor() {
}
}
let cp = new Child(); // ReferenceError
- 由于上述原因,constructor方法中的super方法必须先定义,然后才能调用this对象。
class Parent {
constructor() {}
}
class Child extends Parent {
constructor() {
this.num = 10//报错
super()
this.num = 10//正确写法
}
}
- 如果子类没有定义
constructor
方法,这个方法会被默认添加
class Child extends Parent {
}
// 等同于
class Child extends Parent {
constructor(...args) {
super(...args);
}
}
super
super
这个关键字,既可以当作函数使用,也可以当作对象使用。在这两种情况下,它的用法完全不同。
super函数
super
作为函数调用时,代表父类的构造函数。ES6 要求,子类的构造函数必须执行一次super
函数。- 如果子类中没有定义
constructor
方法,这个方法会被默认添加,相当于已经执行了一次super函数。 super
虽然代表了父类A
的构造函数,但是返回的是子类B
的实例,即super
内部的this
指的是B
的实例,因此super()
在这里相当于A.prototype.constructor.call(this)
。- 作为函数时,
super()
只能用在子类的构造函数之中,用在其他地方就会报错。
super对象
super
作为对象时,在普通方法中,指向父类的原型对象;在静态方法中,指向父类。
class A {
p() {
return 2;
}
}
class B extends A {
constructor() {
super();
console.log(super.p()); // 2
}
}
let b = new B();
上面代码中,子类B
当中的super.p()
,就是将super
当作一个对象使用。这时,super
在普通方法之中,指向A.prototype
,所以super.p()
就相当于A.prototype.p()
。
- 由于
super
指向父类的原型对象,所以定义在父类实例上的方法或属性,是无法通过super
调用的。
class Parent {
constructor(name, sex) {
this.name = name
this.sex = sex
}
sing() {
console.log(this.sex);
}
}
class Child extends Parent {
song() {
super.sing();
}
tell() {
console.log(super.name);
}
}
let xx = new Child('xx', 'boy')
xx.song() //boy
xx.tell() //undefined
-
如果属性定义在父类的原型对象上,
super
就可以取到。 -
ES6 规定,在子类普通方法中通过
super
调用父类的方法时,方法内部的this
指向当前的子类实例。由于this
指向子类实例,所以如果通过super
对某个属性赋值,这时super
就是this
,赋值的属性会变成子类实例的属性。 -
如果
super
作为对象,用在静态方法之中,这时super
将指向父类,而不是父类的原型对象。 -
在子类的静态方法中通过
super
调用父类的方法时,方法内部的this
指向当前的子类,而不是子类的实例。 -
注意,使用
super
的时候,必须显式指定是作为函数、还是作为对象使用,否则会报错。class A {} class B extends A { constructor() { super(); console.log(super); // 报错 } }
上面代码中,
console.log(super)
当中的super
,无法看出是作为函数使用,还是作为对象使用,所以 JavaScript 引擎解析代码的时候就会报错。这时,如果能清晰地表明super
的数据类型,就不会报错。
总结
ES6中的继承:
- 主要是依赖
extends
关键字来实现继承,且继承的效果类似于寄生组合继承 - 使用了
extends
实现继承不一定要constructor
和super
,因为没有的话会默认产生并调用它们 extends
后面接着的目标不一定是class
,只要是个有prototype
属性的函数就可以了
super相关:
- 在实现继承时,如果子类中有
constructor
函数,必须得在constructor
中调用一下super
函数,因为它就是用来产生实例this
的。 super
有两种调用方式:当成函数调用和当成对象来调用。super
当成函数调用时,代表父类的构造函数,且返回的是子类的实例,也就是此时super
内部的this
指向子类。在子类的constructor
中super()
就相当于是Parent.constructor.call(this)
。super
当成对象调用时,普通函数中super
对象指向父类的原型对象,静态函数中指向父类。且通过super
调用父类的方法时,super
会绑定子类的this
,就相当于是Parent.prototype.fn.call(this)
。