Js实现继承的几种方式

一、原型链实现继承

 原型链实现继承的思想：利用原型让一个引用类型继承另一个引用类型的属性和方法。

 原型链的基本概念：  当一个原型对象等于另一个类型的实例，此时的原型对象将包含一个指向另一个指向另一个原型的指针。同时，另一个原型中也包含着一个指向另一个构造函数的指针。如果另一个原型是另一个类型的实例，此时实例和原型就构成了原型链

function SuperType(){
      this.property=true;
}
SuperType.prototype.getSuperValue=function(){
      return this.property;
}
function SubType(){
      this.subproperty=false;
}
//通过创建SuperType的实例继承了SuperType
SubType.prototype=new SuperType();

SubType.prototype.getSubValue=function(){
      return this.subproperty;
}
var instance=new SubType();
alert(instance.getSuperValue());  //true                                      

对于代码的解释：

首先定义了两个类型SuperType和SubType。此时SubType通过创建SuperType的实例（new SuperType()），并将该实例（new SuperType()）赋给了SubType的原型SubType.prototype的方式   继承了 SuperType。

此时存在于SuperType中实例中的所有属性和方法，也存在于SubType.prototype中。此时，实例、原型和构造函数之间的关系如下图所示。

 SubType的实例instance指向SubType的原型SubType.prototype，SubType.prototype又指向SuperType的原型。

注意：getSuperValue()方法仍然还在SuperType.prototype中，但property则位于SubType.prototype中。这是因为property是一个实例属性，而getSuperValue()则是一个原型方法。

原型链存在的问题：

  1）包含引用类型值的原型属性会被所有实例共享，这会导致对一个实例的修改会影响另一个实例。在通过原型来实现继承时，原型实际上会变成另一个类型的实例。原先的实例属性就变成了现在的原型属性

（2）在创建子类型的实例时，不能向超类型的构造函数中传递参数

二、借用构造函数实现继承

借用构造函数的基本思想，即在子类型构造函数的内部调用超类型构造函数。函数只不过是在特定环境中执行代码的对象，因此通过使用apply()和call()方法可以在新创建的对象上执行构造函数。

function SuperType(){
      this.colors=["red", "blue", "green"];
}
function SubType(){
      //继承SuperType
      SuperType.call(this);
}
var instance1=new SubType();
instance1.colors.push("black");
alert(instance1.colors);  //red,bllue,green,black

var instance2=new SubType();
alert(instance2.colors);  //red,blue,green

代码的解释：

 SuperType.call(this);“借调”了超类型的构造函数。通过使用call()方法（或者apply()方法），在新创建的SubType实例的环境下调用了SuperType构造函数。这样一来就会在新的SubType对象上执行SuperType()函数中定义的所有对象初始化代码。结果，SubType的每个实例都会有自己的colors属性副本

借用构造函数的优势：可以在子类型构造函数中向超类型构造函数传递参数

function SuperType(name){
      this.name=name;
}
function SubType(){
      //继承了SuperType,同时还传递了参数
      SuperType.call(this,"mary");//this（SubType的实例）调用SuperType构造函数
      //实例属性
      this.age=22;
}
var instance=new SubType();
alert(instance.name);  //mary
alert(instance.age);  //29

借用构造函数的问题：

1）无法避免构造函数模式存在的问题，方法都在构造函数中定义，因此无法复用函数。

2）在超类型的原型中定义的方法，对子类型而言是不可见的。因此这种技术很少单独使用。

三、组合继承

组合继承：指的是将原型链和借用构造函数的技术组合到一起。思路是使用原型链实现对原型方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数的复用，又能够保证每个实例都有它自己的属性。

function SuperType(name){
      this.name=name;
      this.colors=["red", "blue", "green"];
}
SuperType.prototype.sayName=function(){
      alert(this.name);
};
function SubType(name, age){
      //继承属性    使用借用构造函数实现对实例属性的继承
      SuperType.call(this,name);
      this.age=age;
}
//继承方法     使用原型链实现
SubType.prototype=new SuperType();
SubType.prototype.constructor=SubType;
subType.prototype.sayAge=function(){
      alert(this.age);
};
var instance1=new SubType("mary", 22);
instance1.colors.push("black");
alert(instance1.colors);   //red,blue,green,black
instance1.sayName();  //mary
instance1.sayAge();  //22

var instance2=new SubType("greg", 25);
alert(instance2.colors);   //red,blue,green
instance2.sayName();  //greg
instance2.sayAge();  //25

代码解释：

  SuperType构造函数定义了两个属性：name和colors。SuperType的原型定义了一个方法sayName（）。

  SubType构造函数在调用SuperType构造函数时传入了name参数。并定义了自己的属性age。

然后，将SuperType实例赋值给SubType的原型，然后又在新原型上定义了sayAge方法。
此时可以让两个不同的SubType实例分别拥有自己的属性，又可以使用相同的方法
组合继承的优势：
避免了原型链和借用构造函数的缺点，融合了他们的优点，是JavaScript中最常用的继承模式。instanceof和isprototypeOf()也能够用于识别基于组合继承创建的对象

 四、原型式继承

五、寄生式继承

六、寄生组合式继承

参考文章：

 https://www.cnblogs.com/cjr001/p/7241553.html