js对象的继承方式

es6的继承方式

    // es6 继承比较方便
    class Animal {
        constructor(name) {
          this.name = name|| '动物们';
          this.sleep = function () {
              console.log(this.name+'正在睡觉')
          }
        }
        eat(foot) {
            console.log(this.name+'正在是'+foot);
        }
    }
    class Arr extends Animal{
        constructor(name) {
            super(name)
        }
    }
    var a = new Arr('小猪');
    a.eat('食物')
    a.sleep();
    console.log(a)

原型链继承方式

*好处*
// 非常纯粹的继承关系，实例是子类的实例，也是父类的实例
// 父类新增原型方法/原型属性，子类都能访问到
// 简单，易于实现
// 缺点
// 如果要新增原型属性和方法，则必须放在new Animal()这样的语句之后执行。可以在Cat构造函数中，为Cat构造函数属性
// 来自原型对象的所有属性被所有实例共享。
// 无法实现多继承
// 创建子类实例时，无法向父类构造函数传参

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

    function Cat() {

    }
    Cat.prototype = new Animal('狗');
    var a = new Cat();
    a.sleep()

实例继承

此类继承方式比较简单直接把 new的对象直接付给新的变量就是可以了
子类没法传入自己的参数只是复用父类
方法只能调用父类原型里的方法
缺点
实例是父类的实例，不是子类的实例
不支持多继承
优点
不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果

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

寄生组合式继承

// 优点
// 该方法的好处在于只调用了一次SuperType构造函数，并且SubType.prototype上没有多余的属性。
// 该方法是引用类型最理想的继承方式。
// 缺点
// 写起来麻烦

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

    function Cat(name) {
        Animal.call(this,name);
    }
    function redirect(a,b) {
        var S = function () {} // 一个纯净的构造函数
        S.prototype = b.prototype;
        a.prototype = new S();
        a.prototype.constructor = a;
    }
    redirect(Cat,Animal);

    var b = new Cat('s');
    b.eat('虱')
    b.sleep()

拷贝继承

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

   function Animal (name) {
        // 属性
        this.name = name || 'Animal';
        // 实例方法
        this.sleep = function(){
            console.log(this.name + '正在睡觉！');
        }
    }
    // 原型方法
    Animal.prototype.eat = function(food) {
        console.log(this.name + '正在吃：' + food);
    };
    function Dog(name) {
        Animal.call(this,name);
    }
    for (var i in Animal.prototype) {
        Dog.prototype[i] =  Animal.prototype[i];
    }
    Dog.prototype.constructor = Dog;
    var a = new Dog('哈哈');
    console.log(a);
    a.eat('11');
    a.sleep()

构造函数继承

// 优点
// 创建子类实例时，可以向父类传递参数
// 可以实现多继承（call多个父类对象）
// 缺点
// 实例并不是父类的实例，只是子类的实例
// 只能继承父类的实例属性和方法，不能继承原型属性/方法
// 无法实现函数复用，每个子类都有父类实例函数的副本，影响性能

function Arr(a,b) {
     this.a = a;
     this.b = b
     this.fn = function () {
         console.log(this.a)
     }
 }
 Arr.prototype.console= function () {
     console.log(this.b)
 };
 function F() {
     Arr.call(this); // 构造函数继承
     this.a = '我是贺岁';
     this.b = 'dddd';
 }
 var a = new F(); // 只是子类的实例
 console.log(a)
 a.fn()

组合继承

// 缺点
// 效率较低，内存占用高（因为要拷贝父类的属性）
// 无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）
// 相当于调用两次Animal，造成极大的浪费

// 组合继承
    function Animal (name) {
        // 属性
        this.name = name || 'Animal';
        // 实例方法
        this.sleep = function(){
            console.log(this.name + '正在睡觉！');
        }
    }
    // 原型方法
    Animal.prototype.eat = function(food) {
        console.log(this.name + '正在吃：' + food);
    };
    function Arr(name) {
        Animal.call(this,name) //
    }
    Arr.prototype= new Animal();  // 多复用了一次对象 耗性能 对象的引用关系不能打破
    Arr.prototype.constructor = Arr;     // 需要重新指向构造函数 无法重定向constructor
    var a = new Arr('鸡');
    console.log(a)
    a.eat('种子')

github: https://github.com/wangqiang1122/wang-touch/tree/master/%E7%BB%A7%E6%89%BF