组合继承（通过改变this指向进行继承）

组合继承也被称为伪经典继承，它综合了我们昨天说的原型链和盗用构造函数，将两者的优点结合在了一起。它的基本思想是使用原型链继承原型上的属性和方法，通过盗用构造函数继承实例属性，这样的好处就是可以把方法定义在原型上复用，每个实例又有自己的属性。

    // 先声明一个构造函数 SuperType ，并且给它定义属性
    function SuperType (name) {
        this.name = name;
        this.colors = ["red","yellow","bule"];
    }
    // 给构造函数的原型对象上添加方法 sayName
    SuperType.prototype.sayName = function(){
        console.log(this.name)
    }
    // 声明一个构造函数 SubType
    function SubType(name,age){
        // 通过 call 方法修改 this 指向，这样SubType 这个构造函数就可以访问到构造函数 SuperType 里面的属性以及原型对象上的属性和方法
        SuperType.call(this,name);
        this.age = age;
    }
    // 把刚开始定义的那个构造函数 SuperType 的实例对象赋值称为构造函数 SubType 的原型对象
    SubType.prototype = new SuperType();
    // 给构造函数 SubType 的原型对象添加 sayAge 方法
    SubType.prototype.sayAge = function(){
        console.log(this.age);
    }
    // 实例化 SubType
    let instancel = new SubType("jackson",22);
    //就可以访问自身以及继承下来的属性和方法
    instancel.colors.push("pink");
    instancel.sayName(); // "jackson"
    instancel.sayAge();//22
    console.log(instancel.colors);// ["red", "yellow", "bule", "pink"]
    
    let instance2 = new SubType("bear", 20);
    console.log(instance2.colors); // ["red", "yellow", "bule"]
    instance2.sayName(); // "bear";
    instance2.sayAge(); // 20

组合继承弥补了原型链和盗用构造函数的不足，是js中使用最多的继承模式。

寄生式继承

寄生式继承就是用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。

 // 寄生式继承
    function subobject(obj) {
        let clone = Object(obj);
        clone.sayName = function(){
            console.log("jackson")
        };
        return clone;
    }
    let sub = {
        name:"bear"
    }
    let sup = subobject(sub);
    sup.sayName();//jackson

寄生式继承同样适合主要关注对象，而不在乎类型和构造函数的场景。object()函数不是寄生式继承所必需的，任何返回新对象的函数都可以在这里使用。

寄生式组合继承

组合继承存在这一定的效率问题，它的父类构造函数始终会被调用俩次，一次在创建字类原型时调用，另一次在子类构造函数中调用。本质上子类只需要在执行时重写自己的原型就行了。

    function inheritPrototype(subType, superType) {
        let prototype = Object(superType.prototype); // 创建对象
        prototype.constructor = subType; // 增强对象
        subType.prototype = prototype; // 赋值对象
    }

这个 inheritPrototype()函数实现了寄生式组合继承的核心逻辑。这个函数接收两个参数：子类构造函数和父类构造函数。在这个函数内部，第一步是创建父类原型的一个副本。然后，给返回的 prototype 对象设置 constructor 属性，解决由于重写原型导致默认 constructor 丢失的问题。最后将新创建的对象赋值给子类型的原型。如下例所示，调用 inheritPrototype()就可以实现前面例子中的子类型原型赋值：

   // 先声明一个构造函数 SuperType ，并且给它定义属性
    function SuperType (name) {
        this.name = name;
        this.colors = ["red","yellow","bule"];
    }
    // 给构造函数的原型对象上添加方法 sayName
    SuperType.prototype.sayName = function(){
        console.log(this.name)
    }
    // 声明一个构造函数 SubType
    function SubType(name,age){
        // 通过 call 方法修改 this 指向，这样SubType 这个构造函数就可以访问到构造函数 SuperType 里面的属性以及原型对象上的属性和方法
        SuperType.call(this,name);
        this.age = age;
    }
    inheritPrototype(SubType, SuperType);
    SubType.prototype.sayAge = function () {
        console.log(this.age);
    };

这里只调用了一次 SuperType 构造函数，避免了 SubType.prototype 上不必要也用不到的属性， 因此可以说这个例子的效率更高。而且原型链仍然保持不变。

寄生式组合继承可以算是引用类型继承的最佳模式。

寄生组合继承 就是 组合继承 + 原型继承 的结合体 js内部会把这个寄生组成封装成 extend

function Father(name) {
    this.name = name
    this.hbody = ['吃饭', '睡觉', '打豆豆']
}
Father.prototype.getName = function() {
    console.log(this.name)
}
function Son(name, age) {
    Father.call(this, name)
    this.age = age
}
Son.prototype = Object.create(Father.prototype)
Son.prototype.construtor = Son
let S = new Son('亚瑟', '22')
let F = new Father('李白')
console.log('寄生组合1', S)
console.log('寄生组合2', F)

原型继承

child.prototype=new Parent()
function A(x){
	this.x=x
}
A.prototype.getX=function(){console.log(this.x)}
function B(y){
	this.y=y
}
B.prototype.gety=function(){console.log(this.y)}
B.prototype=new A()
B.prototype.constructor=B//由于B的原型对象指向A的实例了，那么其构造器就会指向A，因此要改一下原型对象中构造器的指向

让子类的原型指向父类的实例，父类的实例的原型链会指向类的原型.这个方式有很大的缺点：当修改子类实例父类实例也会发生变化，因为这里是使用引用的方式，即在同一个内存空间里操作

Object.create（）

创建一个新对象，使用现有的对象来提供新创建的对象的__proto__
即给你的对象提供一个__proto__

继承组合式继承方式

是用call继承和Object.create

        function Person(name){
            this.name=name
        }
        function A(sex){
            Person.call(this,'A extends Person')
            this.sex=sex
        }
        Person.prototype.getName=function(){
            console.log(this.name)
        }
        A.prototype=Object.create(Person.prototype)
        A.prototype.constructor=A

call继承的目的在于将Person的私有属性继承为自己的私有属性，接下来的每个A的实例都会有一个私有属性name=’A extends Person‘，但只用call继承还不够，我们在这里将父构造函数当普通方法调用了，但无法拿到父类原型对象上的属性和方法。因此我们需要将子类原型指向父类的原型。这样给A的prototype原型对象提供了Person.prototype，这样A的实例的__proto__指向A的prototype，A的prototype的__proto__指向Person的prototype。这种组合式继承即拿到了父类的私有属性和方法成为自己的私有属性方法，也拿到了父类公有的属性和方法。是在es6继承之前的最佳方式

图里的A就是Person父类