js 继承

**

原型链继承

**
原型链继承的关键在于三点:
1. 实体对象proto 指向函数对象的prototype属性也就是所谓的原型对象；
2. 原型对象的construnctor默认指向函数对象；
3. 实体对象在new的过程之中默认调用原型对象的constructor对象，也就是说entity.constructor === function.prototype.constructor;

function super(){}
function sub(){}```
sub.prototype.constructor ===  sub; //true
super.prototype.constructor ===  super;//true
var subEntity = new sub();
subEntity.__proto__ === sub.prototype; //true
subEntity.constructor === sub.prototype.constructor;//true

实现原型链继承的方式如下：

  function super(){}
  function sub(){}
  /*这一步会将默认 sub.prototype.constructor的指向
   *由sub改为super，以至于new时是super的实例
  */
  sub.prototype = new super();
  //手动纠正原型链的错误
  sub.prototype.constructor = sub;

这里的弊端:
1.原型链上的属性涉及到引用类型时各个实例对象由于共享原型对象对原型对象的操作会相互影响;
2.父类的构造方法一定，无法动态传入参数。

构造函数的继承

构造函数的继承比较简单,动态改变作用域就可以了

function super(){}
function sub(){
    super.call(this,arg);
}

优势在于动态传递参数给父类的构造函数，不足之处在于无复用性

拷贝式继承

基于已有的对象实现继承:

    function object(o) {
　　　function F() {}
　　　F.prototype = o;
　　　return new F();
　　}

object(superEntity)=>subEntity=>添加具体属性和方法,实质上是浅拷贝。

三种方式的组合-比较完善的方式

构造函数和继承的组合如下:

function super(){}
super.prototype.say = function(){
console.log('super prototype say');
}
function sub(){
    super.call(this,arg);//第二次调用
    this.name = 'haoba';
}
sub.prototype = new super();//第一次调用
sub.prototype.constructor = sub;
sub.prototype.getName = function(){
    return this.name;
}

以上方式结合了构造函数继承和原型继承的优点,会调用两次父类的构造函数，以至于subEntity从父类而来的实例属性覆盖了原型属性,改造一下:

function super(){}
super.prototype.say = function(){
console.log('super prototype say');
}
function sub(){
    super.call(this,arg);//第二次调用,arg为动态传入superconstructor参数
    this.name = 'haoba';
}
sub.prototype = object(super.prototype);//采用拷贝的方式
sub.prototype.constructor = sub;
sub.prototype.getName = function(){
    return this.name;
}

综合了三种继承方式，基本上是最完美的继承方式了