1.传统的组合式继承的缺点。

• 
  
  function SuperType(name,colors){
  
  
• 
  
     this.name=name;
  
  
• 
  
     this.colors=colors;
  
  
• 
  
  }
  
  
• 
  
  SuperType.prototype.getSuperProperty=function(){
  
  
• 
  
      return this.name;
  
  
• 
  
  }
  
  
• 
  
  
  
  
• 
  
  function SubType(job,name,colors){
  
  
• 
  
       SuperType.call(this,name,colors);  //第二次调用基类的构造函数
  
  
• 
  
       this.job=job;  
  
  
• 
  
  }
  
  
• 
  
  
  
  
• 
  
  SubType.prototype=new SuperType();    //第一次调用基类的构造函数
  
  
• 
  
  
  
  
• 
  
  SubType.prototype.getSubProperty=function(){
  
  
• 
  
  return this.job;
  
  
• 
  
  }
  
  
• 
  
  var instance=new SubType("doctor","John",["red","green"]);
  
  
• 
  
  
  
  
• 
  
  console.log(instance.getSuperProperty());  //john
  
  
  

传统的组合式继承，为了使子类拥有自己的实例属性，在子类的构造函数里调用了基类的构造函数，用于覆盖原型链继承的共享属性。所以，组合式继承会两次调用基类的构造函数：第一次，子类的原型声明为基类的一个实例；第二次，子类的构造函数中调用基类的构造函数。

2.寄生组合式继承

• 
  
  <pre name="code" class="javascript">function SuperType(name,colors){
  
  
• 
  
    this.name=name;
  
  
• 
  
    this.colors=colors;
  
  
• 
  
  }
  
  
• 
  
  SuperType.prototype.getSuperProperty=function(){
  
  
• 
  
      return this.name;
  
  
• 
  
  }
  
  
• 
  
  function SubType(job,name,colors){
  
  
• 
  
      SuperType.call(this,name,colors);
  
  
• 
  
       this.job=job;  
  
  
• 
  
  }
  
  
• 
  
  
  
  
• 
  
  
  
  
• 
  
  function inherit(subType,superType){
  
  
• 
  
      var prototype=Object.create(superType.prototype);  
  
  
• 
  
  
  
  
• 
  
      prototype.constructor=subType;
  
  
• 
  
  
  
  
• 
  
      subType.prototype=prototype;
  
  
• 
  
  }
  
  
• 
  
  
  
  
• 
  
  inherit(subType,superType);
  
  
• 
  
  
  
  
• 
  
  SubType.prototype.getSubPrototype=function(){
  
  
• 
  
  return this.job;
  
  
• 
  
  }
  
  
• 
  
  var instance=new SubType("doctor","John",["red","green"]);
  
  
• 
  
  console.log(instance.getSuperPrototype());
  
  
• 
  
  

奈斯