ES6 的类继承时，在子类的 constructor 函数中以 super 方法执行来指定 this

    1. class Parent{
    2.     constructor(name = 'zhangsan'){
    3.         this.name = name;
    4.     }
    5.     say(){
    6.         console.log(1);
    7.     }
    8.     static a(){ // 静态方法无法继承
    9.         console.log(2);
    10.     }
    11. }
    13. // 派生类
    14. class Child extends Parent{
    15.     constructor(name = 'lisi', age = 19){
    16.         super(name); //在constructor 以 super 函数执行来指定 this
    17.         this.age = age;
    18.         this.type = 'child';
    19.     }
    20. }
    22. console.log(new Child().say());

    super 当对象时候

    1. 在对象当中指代对象的原型 ```javascript let proto = { y: 20, z: 40 }

    let obj = { x: 10, foo: super.y, // 报错 不能用于属性 foo: function() { // 报错 console.log(super.y); }, foo: () => { // 报错 console.log(super.y); }, foo() { // 只能用对象方法简写的方法中 console.log(super.y); // 20 } }; 

    2. 2. 在静态方法，指向自己的父类
    3. ```javascript
    4. class Parent {
    5.   static myMethod(msg) {
    6.     console.log('static', msg);
    7.   }
    8.   myMethod(msg) {
    9.     console.log('instance', msg);
    10.   }
    11. }
    13. class Child extends Parent {
    14.   static myMethod(msg) {
    15.     super.myMethod(msg);  // super 指向父类因此访问的是static myMethod
    16.   }
    17.   myMethod(msg) {
    18.     super.myMethod(msg);  // super 指向的是父类的构造函数, 访问的是 Parent.prototype.myMethod
    19.   }
    20. }
    21. Child.myMethod(222); // static 222
    23. let child = new Child();
    24. child.myMethod(111); // instance 111