这篇主要讲了 构造函数实现继承  原型链实现继承 构造函数+原型链实现继承(两种)

1: call() apply()模拟继承 构造函数

思路:在构造函数内部调用call和apply方法,改变将要继承的对象的this指向

call(): 改变函数的作用域,第一个参数是对象,后面是将参数依次填进去

apply(): 和上面一样,区别是传递参数时,需要将参数封装到一个数组中,传递进去

function ClassA (name) {

this.name = name

}

function ClassB (name) {

ClassA.call(this, name) // 更改ClassA的作用域对象

}

优点:这种方法可以实现多继承,ClassB的函数内部调用多个父类函数即可

2:原型链方式

思路就是将构造函数的原型对象的指向将要继承的构造函数的实例

function ClassA () {}

ClassA.prototype.name = 'ClassA' // 注意:使用原型函数模拟类时属性不可添加在原型函数上

ClassA.prototype.say = function () {console.log(this.name)}

function ClassB () {}

ClassB.prototype = new ClassA()

ClassB.prototype.constructor = ClassB // 构造函数的原型函数的构造属性一般指向当前的构造函数

ClassB.prototype.

这种方式就可以使ClaaB继承ClassA,但是这种方式有个弊端,无法实现多继承

注意:原型链方式无法实现多重继承,因为如果ClassA要继承一个类就必须要改变ClassA函数的原型函数的指向,那么在ClassA的原型函数上添加的属性和方法就会无效

这里也许有个疑问,就是构造函数的原型对象上的属性会被多个实例所共享,所以ClassA的属性加到原型对象上,在被ClassB继承后,ClassB的所有实例对象会不会共享ClaasA的原型对象上的属性?

var a= new ClassB()

var b= new ClassB()

a.name= 'a'

a.say() // a

b.say() // ClassA

上面代码中创建两个实例a和b,改变a的属性name,b的并不会改变

理由:

重点是在这段代码ClassB.prototype = new ClassA(),在给ClassB的原型对象赋值时,每次都会创建新的ClassA的实例,也就是说a和b的原型对象的实例不是同一个,自然就会有不同的原型函数

缺点:原型链的方式实现的继承无法在构造函数中(ClassA)添加参数

3:构造函数+原型链实现继承

这种方法可以解决无法给父类的构造函数传参的问题,在js模拟类中便说过模拟类最好的方式就是属性定义在构造函数中,方法加到原型函数上,继承中依然是这样.如下:

function ClassA (name) {

this.name = name

}

ClassA.prototype.say = function () {

console.log(this.name)

}

function ClassB (name, color) {

ClassA.call(this, name)

this.color = color

if (typeof ClassB._initialze === 'undefined' ) {

ClassB.prototype = new ClassA()

ClassB._initialze = true

}

}

在子类的构造函数中使用call()方法便可以解决构造函数无法传参的问题,但是这种继承模式也有缺点，那就是需要调用两次父类的构造函数，

4：现在比较常用的继承方式

思路：父类的方法都写在父类构造函数的原型对象上，属性定义在构造函数内部。在创建子类的构造函数时，在函数的内部使用call方法调用父类的构造方法以此来继承父类的属性，然后取到父类的原型对象赋值给子类的的构造函数的原型兑现。

function changePrototype(subPrototype, superPrototype){

var tem = superPrototype.prototype

tem.constructor = subPrototype

subPrototype.prototype = tem

}

function ClassA (name) {

this.name = name

}

ClassA.prototype.say= function () {}

function ClassB (name) {

ClassA.call(this, name)

}

changePrototype(ClaasB, ClassA)

这种方式可以避免调用两次父类构造函数，但是这种方式也有缺点，无法实现多次继承，比如现在有abc三个构造函数，使用这种方法b继承a，c就无法继承a了，因为原型对象只有一个，当b继承a后，constructor 指向b，无法指向c