继承的几种方式

构造函数,原型和实例的关系
每个构造函数都有一个原型对象prototype,原型对象中有个constructor属性,该属性指向构造函数本身,每个实例都有一个指向原型对象的内部指针proto,如果原型对象是另一个实例,那原型对象中又包含一个指向其原型的指针
所有引用类型都是继承了object
所有函数的默认原型都是Object的实例
默认原型中包含一个指针指向object.prototype

image.png

image.png

1、原型链

  function Animal() {
       this.color=['red','blue']
   }
   Animal.prototype.eat=function(){
       console.log('eat')
   };

   function Dog(){

   }

   Dog.prototype=new Animal();

   let dog=new Dog();
   console.log(dog.color);
   dog.eat(); //eat

原型链继承还有个毛病,就是在创建子类型的实例时,不能向父类传递参数
第二个是引用类型值的原型,当一个实例改变这个值的时候,在所有的实例上都有所表现,所以会用借用构造函数的方式继承
通过原型链继承的时候不能用对象字面量创建原型方法,这样会重写原型链


image.png

2、借用构造函数

利用函数是在特定环境中执行代码的对象,使用call或者apply可以让父类的构造函数在将来创建的新对象里执行

super.call(this)//其实这个this指的就是当前的对象,
//因为用new 构造出来的实例,会把this指向该实例本身,所以

function Father(name) {
        this.name=name
    }

    function Child(age) {
        Father.call(this,'小黄')
        this.age=age;
    }
    let child=new Child(19)
    console.log(child);//Child {name: "小黄", age: 19}

借用构造函数模式也存在一些问题,方法都在构造函数中定义,所以函数就没发重用了,而且在父类的原型中定义的方法,在子类中都是不可见的,因为只是继承了父类的构造函数中的方法,所以借用构造函数不会单独使用

3、组合继承

这个继承方式的思路是,讲原型链继承和借用构造函数继承组合到一起,使用原型链对原型属性和方法的继承,通过借用构造函数实现对实例属性的继承

function Father(name) {
        this.name=name
    }
     Father.prototype.sayName=function () {
         console.log(this.name);
     }
    function Child(name,age) {
        Father.call(this,name)
        this.age=age;
    }
    Child.prototype=new Father();
    Child.prototype.sayAge=function(){
        console.log(this.age);
    }
    let child1=new Child('xiao',13);
        child1.sayName();
        child1.sayAge()

    let child2=new Child('big',14);
        child2.sayName()
         child2.sayAge();

父类的构造函数定义了一个name 属性,父类的原型上定义 了一个sa yName()的方法,子类构造函数在调用父类构造函数的时候传入了name参数,然后又定义了自己的属性age,然后将父类的实例赋给了子类的原型,又在子类的原型上定义了sayAge()方法,这样子类的不同实例就可以分别拥有自己的属性和使用一样的方法了

4、原型式继承

借助原型,基于已有的对象创建新的对象

 let person={
            name:"小红",
            age:13
        }
 let antherPerson=Object.create(person)
         antherPerson.name="小黑"
         antherPerson.age=15
也可以这样写
 let person={
            name:"小红",
            age:13
        }

        let antherPerson=Object.create(person,{
            name:'小黑'
        })

在没有必要创建构造函数的时候,只是想让一个对象和另一个对象保持类似的情况下这种方法就是可以了,不过引用类型还是会共享,这相当于是对象的浅拷贝

5、寄生式继承

 function object(o) {
             function F() {}
             o.prototype=F;
             return new F();
         }
        function createPerson(original){
            let clone=object(original);//通过调用函数创建一个新的对象
            clone.say=function () {
                console.log('hi')  //以某种方式增强这个对象
            }
            return clone;//返回这个对象
        }

let person={
            name:"小红",
            age:13
        }

      let anotherPerson=createPerson(person);
         anotherPerson.say()

上面代码中基于person 返回另一个新对象,这个对象拥有person的所有属性和方法,还有自己的say()方法
但是寄生式继承的方式为对象添加函数也不能复用,这样会降低效率,和构造函数模式类似

6、寄生组合式继承

由于组合式继承会调用两次父类的构造函数,第一次是在创建子类原型的时候,第二次是调用子类构造函数内部调用父类的时候,
在第一次调用父类构造函数的时候,Child.prototype会得到一个name 属性,它是父类的实例属性,不过现在在子类的原型中,
在调用子类构造函数的时候,又一次调用父类的构造函数,不过这次又在新对象上创建了实例属性name,这个属性就屏蔽了原型中的的同名属性,为了解决这个,就用寄生组合继承

function Father(name) {
        this.name=name
    }
     Father.prototype.sayName=function () {
         console.log(this.name);
     }
    function Child(name,age) {
        Father.call(this,name)//第二次调用父类构造函数
        this.age=age;
    }
    Child.prototype=new Father();//第一次调用
    Child.prototype.constructor=Child

寄生组合式继承的思想:通过借用构造函数继承属性,通过原型链的混成形式来继承方法,不必为了指定子类型的原型而调用构造函数,我们只需要一个父类原型的副本,

function Animal(color){
     this.color = color
 }
 function Dog(color, name){
     Animal.call(this, color) // 或者 Animal.apply(this, arguments)
     this.name = name
 }

 function temp(){}
 temp.prototye = Animal.prototype //父类原型的副本
 Dog.prototype = new temp()

 Dog.prototype.constuctor = Dog  //把原型中的constrcutor指向子类的构造函数

 var dog = new Dog('黄色','小黄')

最优的继承就是寄生组合式继承

推荐阅读更多精彩内容