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",成功调用在父类原型定义的方法


最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容

  • 面向对象编程是用抽象方式创建基于现实世界模型的一种编程模式,主要包括模块化、多态、和封装几种技术。对 JavaSc...
    吴佳浩阅读 522评论 0 4
  • 面向对象的语言有一个标志,那就是它们都有类的概念,而通过类可以创建任意多个具有相同属性和方法的对象。ECMAScr...
    DHFE阅读 1,007评论 0 4
  • 一、 JS面向对象编程 1、 面向对象介绍 什么是对象? Everything is object (万物皆对象)...
    宠辱不惊丶岁月静好阅读 849评论 0 2
  • 第一章 错误处理: 错误: 程序运行过程中,导致程序无法正常执行的现象(即bug) 现象: 程序一旦出错,默认会报...
    fastwe阅读 1,151评论 0 1
  • 经历过被国内良莠不齐的英语教师的毒害,至今很多家长也没办法有底气地讲英语。于是很多家长把目光,放在了线上英语平台上...
    三点一线艾js阅读 2,879评论 0 0