js继承有四种方式
1. 构造函数绑定
使用call或apply方法，将父对象的构造函数绑定在子对象上，即在子对象构造函数中加一行：
function Animal(){
this.species = "Animal";
}
function Cat(name, color){
Animal.apply(this, arguments);
this.name = name;
this. color = color;
}
var cat1 = new Cat("mimi","yellow");
alert(cat1.species);//Animal
缺点：无法实现函数复用
2. prototype 模式
Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;
var cat1 = new Cat("mimi", "yellow");
alert(cat1.species);//Animal
3. 组合继承
function Animal(){}
Animal.prototype.species = "Animal"
function Cat(name,color){
Animal.call(this);
}
Cat.prototype = new Animal();
var cat1 = new Cat("mimi", "yellow");
alert(cat1.species);//Animal
4. 利用空对象作为中介
((function(){
ler Super = function{};
super.prototype = Animal.prototype;
Cat.prototype = new Super();
})();
Cat.prototype.constructer = Cat;
var cat1 = new Cat("大毛","黄色"); alert(cat1.species); // 动物
5.ES6实现继承
class可以通过extends实现继承
class ColorPoint extends Point {
constructor(x, y, color) {
super(x, y); // 调用父类的constructor(x, y)
this.color = color;
}
toString() {
return this.color + ' ' + super.toString(); // 调用父类的toString()
}
}
子类必须在 constructor方法中调用super方法，否则新建实例时会报错
另外，在子类的构造函数中，只有调用super之后，才可以使用this关键字，否则会报错
Object.getPrototypeOf()
Object.getPrototypeOf(ColorPoint) === Point
因此，可以使用这个方法判断，一个类是否继承了另一个类
super关键字
super作为函数调用时，代表父类的构造函数，ES6要求，子类的构造函数必须执行一次super函数
super虽然代表了父类A的构造函数，但是返回的是子类B的实例，即super内部this指向的是B
作为函数，super只能用在子类的构造函数中。
第二种情况，super作为对象时，在普通方法中，指向父类的原型对象（prototype）；在静态方法中，指向父类
class A{
p(){
return 2;
}
}
class B extend A{
constructor(){
super();
console.log(super.p());
}
}
let b = new B();
上面代码中，子类B当中的super.p()，就是将super当作一个对象使用。这时，super在普通方法之中，指向A.prototype，所以super.p()就相当于A.prototype.p()
ES6规定，在子类普通方法中通过super调用父类的方法时，方法内部的this指向当前的子类实例；
class A {
constructor() {
this.x = 1;
}
print() {
console.log(this.x);
}
}
class B extends A {
constructor() {
super();
this.x = 2;
}
m() {
super.print();
}
}
let b = new B();
b.m() // 2
class A {
constructor() {
this.x = 1;
}
}
class B extends A {
constructor() {
super();
this.x = 2;
super.x = 3;
console.log(super.x); // undefined
console.log(this.x); // 3
}
}
let b = new B();
上面代码中，super.x 赋值为3，这时等同于this.x 赋值为3；而当读取super.x的时候，读的是A.prototype.x, 所以返回undefinded
class A {}
A.prototype.x = 2;
class B extends A {
constructor() {
super();
console.log(super.x) // 2
}
}
let b = new B();
上面代码中，属性x是定义在A.prototype上面的，所以super.x可以取得值
ES6 规定，在子类普通方法中通过super调用父类的方法时，方法内部的this指向当前的子类实例。
class A {
constructor() {
this.x = 1;
}
print() {
console.log(this.x);
}
}
class B extends A {
constructor() {
super();
this.x = 2;
}
m() {
super.print();
}
}
let b = new B();
b.m() // 2
上面代码中，super.print()虽然调用的是A.prototype.print(),但是A.prototype.print()内部的this指向子类B的实例，导致输出的是2，而不是1
如果super作为对象，用在静态方法之中，这时super将指向父类，而不是父类的原型对象
class Parent {
static myMethod(msg) {
console.log('static', msg);
}
myMethod(msg) {
console.log('instance', msg);
}
}
class Child extends Parent {
static myMethod(msg) {
super.myMethod(msg);
}
myMethod(msg) {
super.myMethod(msg);
}
}
Child.myMethod(1); // static 1
var child = new Child();
child.myMethod(2); // instance 2
