js的继承简介

首先简单的介绍一下面向对象的三大特性

封装：将属性和方法封装成一个对象，实现一系列的功能，使用的时候只需要向外界暴露接口，并不需要关心对象内部是怎么样实现的。
继承：在js中，一个对象没有某些属性或者方法，另外一个对象中有，那么我们可以从另外一个对象中拿过来用。
多态：在js中是不支持多态的（其实是父类指针指向子类对象）

接下来我们主要介绍js中的几种常用的继承方式

混入式继承

// 构造函数
function Parent(){};
function Child(){};

// 实例化对象
var parent  = new Parent();
var child = new Child();
for(var k in parent){
  child[k] = parent[k]
}

优点：简单易理解
缺点：针对父类中的引用类型，多个实例对象会共享，所以在操作的同一个引用类型时会相互影响

原型链继承

修改原型对象实现继承

//构造函数
 function Parent(){
     this.name = 'zs'
      this.arr = [1,2,3];
  }
 function Child(){}
 
 var person = new Parent();
 for(var k in person){
  Child.prototype[k] = person[k]; // 让孩子原型去继承父亲new出来对象的属性
 }
 var child1 = new Child();
 child1.arr.push(4);
 console.log(child1.arr);  // [1,2,3,4]
 var child2 = new Child();
 console.log(child1.arr); // [1,2,3,4]
 console.log(Child.prototype.constructor) // ==>指向Child构造函数

通过替换原型对象实现继承（子类的原型指向父类的实例）

// 构造函数
 function Parent(){
     this.name = 'zs'
     this.arr = [1,2,3];
 }
 function Child(){}
 
 var person = new Parent();
 Child.protoType = person; // 替换原型对象之后，constructor属性会丢失
 Child.protoType.constructor = Child; // 解决constructor属性丢失的问题

优点：简单易理解
缺点：原型链中的引用类型的属性会被所有的实例共享，即所有的实例对象使用的是同一份数据，会相互影响。无法向父类构造函数传参。通过原型链实现继承后，不能再使用字面量的方式创建原型对象，因为会覆盖原型链。

经典继承（原型式继承，子类的原型指向父类副本的实例）

  var obj = Object.create(obj1);// 创建一个obj对象，原型对象是是obj1, 但是他有兼容性有问题
  // 解决兼容性问题
  if(Object.create){
   var obj = Object.create(obj1);
  } else {
   function F = {};
   F.prototype = obj1;
   var f = new F; // 构造函数没有参数时，创建对象后边的小括号可以不加
   return f
}

借用构造函数继承

function Parent(name){
  this.name = name;
}

function Child(){
 Parent.call(this); // 将Parent的this指向通过Child构造函数new出来的对象 等同于 Parent.call(child1)
}
var child1 = new Child(); // 这样每个实例都会有一份Parent中的属性方法的副本，而且每个实例都是单独的，互相不影响

优点：这样每个实例都会有一份Parent中的属性方法的副本，而且每个实例都是单独的，互相不影响。子类对象可以向父类对象进行传参的操作了
缺点：每个实例都拷贝一份，占用内存大，尤其是方法过多的时候，构造函数继承是需要把所有的属性和方法都放到构造函数中，那与在原型上添加方法实现复用是冲突的。
Child只能继承Parent自身的属性，而无法继承Parent原型中的方法。

组合继承（将原型链和借用构造函数组合到一起，原型链实现对原型方法的继承，而通过借用构造函数来实现对实例属性的继承）

//父类
function Parent(name) {
this.name = name
this.arr = [1,2,3]
}

Parent.prototype.getName = function() { // ① 我们将 Parent 类中需要复用的方法提取到 Parent.prototype 中
console.log(this.name)
}

// 子类
function Child(name, age) {
// ③ 为保证 child1 和 child2 拥有各自的父类属性副本，我们在 Child 构造函数中，还是使用了 Parent.call ( this ) 方法。
// 它只能继承构造函数里的属性和方法
Parent.call(this, name) 
this.age = age
}

//  ②  Child 的原型对象为 Parent 类的一个实例。
// 这样 child1 就能访问到 Parent 原型对象上的属性和方法了
Child.prototype = new Parent(); 
Child.prototype.constructor = Child
Child.prototype.getAge = function() { // age用的是Child自己的属性
console.log(this.age)
}

var child1 = new Child("张三", 20)
child1.arr.push(4)
console.log(child1.arr) //1,2,3,4
child1.getName()    //张三
child1.getAge()     //20

var child2 = new Child("李四", 21)
console.log(son2.arr) //1,2,3
child2.getName()    //李四
child2.getAge()     //21

寄生式继承
创建一个仅用于封装继承过程的函数

function inherit(o) {
    var clone = Object.create(o) // 创建一个新对象
    clone.sayHi = function() { // 让返回的新对象不仅继承person的属性和方法，还可以拥有自己的sayHi方法
        console.log('hi')
    }
    return clone // 返回这个对象
}

var person = {
    name: 'zs'
}

var child = inherit(person);
child.sayHi()

寄生组合继承（完美的继承）
由于组合继承，会导致父类的构造函数被调用两次，而寄生继承不用实例化父类，而是实例化一个临时副本实现了相同的原型链继承。

// 父类
function Parent(name,colors){
  this.name = name;
  this.colors = colors;
}
Parent.prototype.getParentProperty = function(){ return this.name; }

// 子类
function Child(job,name,colors){
  Parent.call(this,name,colors); // 属性继承
  this.job=job;
}
Child.prototype.getChildPrototype = function(){ return this.job; }


function inherit(child,parent){ // 原型式继承,子类会继承父类原型上的属性和方法，而不能继承构造函数的方法
  var prototype = Object.create(parent.prototype); // 创建父类原型的副本
  prototype.constructor = child;
  child.prototype = prototype; // 将子类的原型指向副本
}
inherit(Child,Parent);
var instance = new Child("doctor","Jack",["red","green"]);
console.log(instance.getChildPrototype());  //输出"doctor"
console.log(instance.getParentProperty());  //输出"Jack"，成功调用在父类原型定义的方法

js的继承简介

首先简单的介绍一下面向对象的三大特性

接下来我们主要介绍js中的几种常用的继承方式

推荐阅读更多精彩内容