静态属性，super()

静态属性： 只能被类调用的属性

在ES5中 静态属性写法

function MyClass() {

    }
    // ES5 静态属性写法
    /*MyClass.say = function () {
      console.log('这是一个静态方法');
    }

    const obj = new MyClass();*/

在ES6中 静态属性写法

 // ES6
    /*class MyClass {
      constructor() {
      }
      // 静态方法  只有静态方法没有静态属性
      static say() {


      }
    }*/

super()

第一种情况： super作为函数调用时，代表父类的构造函数。
ES6中要求，子类的构造函数必须执行一次super函数
作为函数时，super()只能在子类的构造函数中，用在其他地方会报错

Class A {
	constructor() {
	}
}
Class B extends A {
	constructor() {
		super();
	}
}

【注】super虽然代表了父类A的构造函数，但是返回的是子类B的实例，即super内部的this指向的是B。因此super()在这里相当于A.prototype.constructor.call(this)

class FatherClass {
        // constructor可不用写，在new的时候会默认添加
        // 但是在继承的时候，子类的constructor是必须的，否则报错，因为constructor中的super是必写的，所以constructor也必写
    }
    class MyClass2 extends FatherClass{
        constructor() {
            super(); // 本次super 相当于父类Class
            // 为什么必须调用这一步？？
            // 在newFatherClass这个实例的时候，会默认生成一个对象，this会指向这个对象。
            // 但使用继承，如果不调用super，那么这个子类不会生成对象，也不会有this,没有this这个实例，也就无法返回出来
            // 没有this，那么就不能给他挂属性（this.属性），也就不能当作一个类来使用
            // 所以必写的这一步除了继承父类的私有属性，还让子类拥有this对象

            // super()这一步相当于ES5中的FatherClass.call(this);
        }
        // 静态方法 没有静态属性
        static say() {

        }
    }

第二种情况： super作为对象时，在普通方法种，指向父类的原型；在静态方法中，指向父类

Class A {
	P() {
		return l2;
	}
}
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()
由于this指向子类，所以如果通过super对某个属性赋值，这时super就是this，赋值的属性会变成子类实例的属性

class FatherClass {

    }
    class MyClass2 extends FatherClass{
        constructor() {
            super(); // 本次super 指向父类，相当于 父类()
            super.say(); // 相当于FatherClass.prototype.say()
        }

        // 静态方法 没有静态属性
        static say() {
            // super可在这出现，但不能作为函数调用，当作为函数调用的时候只能出现在constructor中
            // 但super这个关键字能出现在原型方法和静态方法中
            // 这里的super指向父类
            // 这里也指向父类？ 在这里是调用 父类.静态方法，而上面的是 父类()
        }

        // 原型方法
        add() {
            // 这里的super指向父类的原型。FatherClass.prototype
        }
    }