js继承7中方式

// 定义一个动物类 父类

  function Animal(name) {
    // 属性
    this.name = name || "Animal";
    // 实例方法
    this.sleep = function () {
      console.log(this.name + "正在睡觉！");
    };
  }
  // 原型方法
  Animal.prototype.eat = function (food) {
    console.log(this.name + "正在吃：" + food);
  };

 1. 原型链继承
    核心： 将父类的实例作为子类的原型
    优点：
        1.简单易于实现，父类的新增的实例与属性子类都能访问
    缺点：
        1.可以在子类中增加实例属性，如果要新增加原型属性和方法需要在new 父类构造函数的后面
        2.无法实现多继承
        3.创建子类实例时，不能向父类构造函数中传参数

 function Cat() {}
 Cat.prototype.name = "cat";
 Cat.prototype = new Animal();
 //　Test Code
 var cat = new Cat();
 console.log(cat.name);
 console.log(cat.eat("fish"));
 console.log(cat.sleep());
 console.log(cat instanceof Animal); //true
 console.log(cat instanceof Cat); //true
           

   2.构造继承
     核心：使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）
     优点：
          1.解决了子类构造函数向父类构造函数中传递参数
          2.可以实现多继承（call或者apply多个父类）
      缺点：
          1.方法都在构造函数中定义，无法复用
          2.不能继承原型属性/方法，只能继承父类的实例属性和方法

function Cat(name) {
   Animal.call(this);//Animal.call(this，'大黄');
   this.name = name || "Tom1";
 }
 // Test Code
 var cat = new Cat();
 console.log(cat.name);
 console.log(cat.sleep());
 console.log(cat instanceof Animal); // false
 console.log(cat instanceof Cat); // true */

 3.实例继承
        核心：为父类实例添加新特性，作为子类实例返回
        特点：
            1.不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
        缺点：
            2.实例是父类的实例，不是子类的实例
            3.不支持多继承

               function Cat(name){
                   var instance = new Animal();
                   instance.name = name || 'Tom';
                   return instance;
                   }
                   // Test Code
                   var cat = new Cat();
                   console.log(cat.name);
                   console.log(cat.sleep());
                   console.log(cat instanceof Animal); // true
                   console.log(cat instanceof Cat); // false */

 4.拷贝继承
     优点：
         1.支持多继承
     缺点：
         1.效率较低，内存占用高（因为要拷贝父类的属性）
         2.无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）

  function Cat(name){
        var animal = new Animal();
        for(var p in animal){
        Cat.prototype[p] = animal[p];
        }
        this.name = name || 'Tom';
    }

    // Test Code
    var cat = new Cat();
    console.log(cat.name);
    console.log(cat.sleep());
    console.log(cat instanceof Animal); // false
    console.log(cat instanceof Cat); // true */

 5.组合式继承
  调用父类构造函数，继承父类的属性，通过将父类实例作为子类原型，实现函数复用
 缺点：
     1.由于调用了两次父类，所以产生了两份实例
 优点：
     1.函数可以复用
     2.不存在引用属性问题
     3.可以继承属性和方法，并且可以继承原型的属性和方法

   function Cat(name){
   Animal.call(this);
   this.name = name || 'Tom';
   }
   Cat.prototype = new Animal();

   Cat.prototype.constructor = Cat;

   // Test Code
   var cat = new Cat();
   console.log(cat.name);
   console.log(cat.sleep());
   console.log(cat instanceof Animal); // true
   console.log(cat instanceof Cat); // true */

   6.寄生组合继承
   通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点
   缺点：
       1.实现较为复杂
   优点：
       1.完美

  function Cat(name){
   Animal.call(this);
   this.name = name || 'Tom';
   }
   (function(){
   // 创建一个没有实例方法的类
   var Super = function(){};
   Super.prototype = Animal.prototype;
   //将实例作为子类的原型
   Cat.prototype = new Super();
   })();

   Cat.prototype.constructor = Cat; // 需要修复下构造函数
   // Test Code
   var cat = new Cat();
   console.log(cat.name);
   console.log(cat.sleep());
   console.log(cat instanceof Animal); // true
   console.log(cat instanceof Cat); //true */

  7.es6继承
    //class 相当于es5中构造函数
    //class中定义方法时，前后不能加function，全部定义在class的protopyte属性中
    //class中定义的所有方法是不可枚举的
    //class中只能定义方法，不能定义对象，变量等
    //class和方法内默认都是严格模式
    //es5中constructor为隐式属性

  class People{
  constructor(name='wang',age='27'){
      this.name = name;
      this.age = age;
  }
  eat(){
      console.log(`${this.name} ${this.age} eat food`)
  }
  }
  //继承父类
  class Woman extends People{ 
  constructor(name = 'ren',age = '27'){ 
      //继承父类属性
      super(name, age); 
  } 
      eat(){ 
      //继承父类方法
      super.eat() 
      } 
  } 
  let wonmanObj=new Woman('xiaoxiami'); 
  wonmanObj.eat(); */

  ES5继承和ES6继承的区别

    es5继承首先是在子类中创建自己的this指向，最后将方法添加到this中

    Child.prototype=new Parent() || Parent.apply(this) || Parent.call(this)

    es6继承是使用关键字先创建父类的实例对象this，最后在子类class中修改this