在模拟实现class继承之前，如果还不熟悉JavaScript的继承，可以看一下这篇文章JavaScript继承

    首先看一下ES6的继承

    1. // ES6继承
    3. class Animal {
    4.   static footer = 'footer'
    6.   constructor(opt) {
    7.     this.name = opt.name
    8.   }
    10.   getName() {
    11.     return this.name
    12.   }
    14. }
    16. class Cat extends Animal {
    17.   constructor(opt) {
    18.     super(opt)
    20.     this.age = opt.age
    21.   }
    23.   getAge() {
    24.     return this.age
    25.   }
    26. }
    28. const cat = new Cat({ name: 'miao', age: 5 })

    在上面代码中，Cat继承Animal，通过使用extends继承Animal原型上的方法，通过super调用父构造函数

    关于super：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/super

    super([arguments]); // 调用 父对象/父类 的构造函数 super.functionOnParent([arguments]); // 调用 父对象/父类 上的方法

    我们要想模拟实现ES6继承，关键看ES6 class extends最终转成ES5是什么样，这里急用Babel工具：在线转换，
    摘出最主要的代码

    1. function _inherits(subClass, superClass) {
    2.   if (typeof superClass !== "function" && superClass !== null) {
    3.     throw new TypeError("Super expression must either be null or a function");
    4.   }
    5.   subClass.prototype = Object.create(superClass && superClass.prototype, {
    6.     constructor: { value: subClass, writable: true, configurable: true }
    7.   });
    8.   if (superClass) _setPrototypeOf(subClass, superClass);
    9. }
    13. // ES6继承
    14. var Animal =
    15.   /*#__PURE__*/
    16.   (function() {
    17.     function Animal(opt) {
    18.       _classCallCheck(this, Animal);
    20.       this.name = opt.name;
    21.     }
    23.     _createClass(Animal, [
    24.       {
    25.         key: "getName",
    26.         value: function getName() {
    27.           return this.name;
    28.         }
    29.       }
    30.     ]);
    32.     return Animal;
    33.   })();
    35. _defineProperty(Animal, "footer", "footer");
    37. var Cat =
    38.   /*#__PURE__*/
    39.   (function(_Animal) {
    40.     _inherits(Cat, _Animal);
    42.     function Cat(opt) {
    43.       var _this;
    45.       _classCallCheck(this, Cat);
    47.       _this = _possibleConstructorReturn(
    48.         this,
    49.         _getPrototypeOf(Cat).call(this, opt)
    50.       );
    51.       _this.age = opt.age;
    52.       return _this;
    53.     }
    55.     _createClass(Cat, [
    56.       {
    57.         key: "getAge",
    58.         value: function getAge() {
    59.           return this.age;
    60.         }
    61.       }
    62.     ]);
    64.     return Cat;
    65.   })(Animal);
    67. var cat = new Cat({
    68.   name: "miao",
    69.   age: 5
    70. });

    其中最主要的是 _inherits(Cat, _Animal); 和 _getPrototypeOf(Cat).call(this, opt) ，看到这里我们发现有点像寄生组合式继承。别急，还有跟他不一样的地方，
    我们运行转换后的代码，看一下Cat.__proto__
    image.png
    发现Cat.proto是指向Animal的，在转换后的代码中也能找到对应的地方，就是在_inherits函数最后一句

    所以es6 class的继承实现就是在寄生组合式继承的基础上将子类的proto属性指向父类，为什么要这样做？
    因为寄生组合式继承没法继承父类的静态方法

    模拟实现：

    1. function inherit(Sub, Sup) {
    2.   // Object.create和原型式继承一样，返回一个参数对象的副本
    3.   // 寄生式继承+原型链继承
    4.   const prototype = Object.create(Sup.prototype)
    6.   Sub.prototype = prototype   // 改变子类构造函数的prototype
    7.   Sub.prototype.constructor = Sub
    9.   Sub.__proto__ = Sup
    10. }
    12. function SupType(name) {
    13.   this.name = name
    14.   this.colors = ['red']
    15. }
    17. SupType.prototype.getName = function(){
    18.   return this.name
    19. };
    21. function SubType(name,age) {
    22.   this.age = age
    23.   // 构造函数继承
    24.   SupType.call(this, name)
    25. }
    27. inherit(SubType, SupType)
    28. SubType.prototype.getAge = function() {
    29.   return this.age
    30. }
    32. const sub = new SubType('streetex', 25)