关于JS继承

关于JS继承

关于继承这个概念，是由面向对象衍生出来的。而JS身为一种基于面向对象而设计的语言，它和正统的面向对象语言又是有差别的。

面向对象语言

身为面向对象语言需要对开发者提供四种能力：
①：封装 - 把相关的信息（无论数据或方法）存储在对象中的能力；
②：聚集 - 把一个对象存储在另一个对象内的能力；
③：多态 - 编写能以多种方法运行的函数或方法的能力；
④：继承 - 有另一个或多个类得来类的属性和方法的能力；
虽然JS都具备这种能力，然而它却和正统的面向对象语言有差异,具体表现主要在第③、④点。

多态

多态主要有两种实现形式：
①：重载（编译时多态性） - 方法名相同，形参个数或类型不同；
②：重写（运行时多态性） - 在继承中，子类重写父类的方法；
这两种形式上JS和java/C#是表现形式是不一样的。
重载：

// java代码示例 public void sum(int n, float m){  } public void sum(int n, float m, int t){      } public void sum(int n, float m, String t){      } 

在java中这sum方法会分别在不同情况下调用。

// js代码示例 function sum(n,m){  } function sum(n,m,t){  } 

在JS中sum方法在前面定义的会被后面定义的覆盖，因此JS用相同方法处理不用情况只能在sum方法内部对数据做识别判断了。
重写：

//java代码示例 public class Main {      public static void main(String[] args) {         Student a = new Student();         a.say();     } }  class person{     public void say(){         System.out.println("11111");     } }  class Student extends person{     public void say(){         System.out.println("22222");     } } 

这里Student继承了person，对say方法进行了重写，虽然重写了say方法，但是父类方法不会被改变。

//js代码示例 function A(m){     this.m = m; } A.prototype.getM = function(){     console.log(100,this.m) }  function B(n){     this.n = n; } B.prototype = new A(100); B.prototype.getN = function(){     console.log(this.n) }  let b = new B(200); b.getM();   //打印 100,100  b.getM = function(){     console.log(1) } b.getM();   //打印 1 A.prototype.getM(); //打印 100,undefined  b.__proto__.__proto__.getM = function(){     console.log(0,this.m) };  b.getM();   //打印 1 A.prototype.getM(); //打印 0,undefined 

而JS对继承的父类的重写就有点不一样了，JS是基于原型链的继承。调用方法或对象时会在原型链中追溯，而当在实例b中添加了getM方法时，其实是拦截了原型链上的getM,因此这种拦截不会改动到A.prototype.getM，然而A.prototype.getM又不是绝对的私密的，在示例中可以看到利用b.__proto__.__proto__.getM重写getM是会导致A.prototype.getM也被重写的，所以js原型链继承中是没有完整意义上的私密属性的。

继承

和其他正统的面向对象语言不一样，其他语言的继承一般都是拷贝继承，也就是子类会把父类中的方法和属性拷贝的子类中实现继承，而JS的继承是把父类的原型放在子类的原型链上，利用原型链的查找机制实现继承的。
而且JS的继承方式也是很多的，下面列举一下比较常见的继承方式。

一、原型链继承

function A(m){     this.m = m; } A.prototype.getM = function(){     console.log(this.m) }  function B(n){     this.n = n; } B.prototype = new A(100); B.prototype.getN = function(){     console.log(this.n) }  let b = new B(200); b.getN();   //输出 200 b.getM();   //输出 100 

特点：
1、非常纯粹的继承关系，实例是子类的实例，也是父类的实例；
2、父类新增属性或其原型新增属性，子类都能访问；
缺点：
1、子类能重写父类方法，如：b.__proto__.__proto__.getM = null，可以改写父类方法；
2、父类的私有属性和公有属性都变成子类的公有属性；
3、继承时方法B原型上原有的方法或属性会丢失，如：constructor构造函数；（解决：B.prototype = B）；
4、子类创建实例时无法向父类传参；
5、无法实现多继承；

二、构造函数继承

function A(m, n){      this.m=m;      this.n=n; }  function B(m, n, t){     A.call(this, m, n);      this.t=t; }  var b = new B(1, 2, 3); console.log(b.m, b.n, b.t); 

特点：
1、能在子类创建实例时向父类传递参数；
2、可以实现多继承；
缺点：
1、只能继承父类的属性（不继承原型链）；
2、创建的实例携带着父类属性，臃肿；

三、寄生组合继承

function B(n){     this.n = n; } B.prototype.getB = function(name){     console.log(this.n, name); }  function A(m){     B.call(this,200)     this.m = m; }  // 我是旧时代的残党,新时代没有适合承载我的船 // (function(){ //   // 创建一个没有实例方法的类 //   var Super = function(){}; //   Super.prototype = B.prototype; //   //将实例作为子类的原型 //   A.prototype = new Super(); // })();  // ECMAScript 5 通过新增 Object.create()方法规范化了原型式继承。 A.prototype = Object.create(B.prototype);  A.prototype.constructor = A; A.prototype.getA = function(name){     console.log(this.m, name) }  var aa = new A(100); aa.getA("A"); aa.getB("B"); 

特点：
1、可以继承父类的属性及其原型上的属性；
2、既是子类的实例，也是父类的实例；
3、不存在引用属性共享问题；
4、父类可接收传参；