tips：接下去会在github写博客，简书不再更新和修改文章，欢迎大家逛逛我的新博客点击查看 ，我会尽量用更容易理解的方式写好每一篇博客,大家一起学习交流😄。
继承
概念
OO语言中支持两种继承方式：实现继承，接口继承
- 实现继承：继承实际的方法
- 接口继承：继承函数签名
由于函数没有签名，在ECMAScript中只支持实现继承，而且是依靠原型链来实现的
原型链
[图片上传失败...(image-c69d0c-1522079505212)]
原型链的问题（缺点）
- 1、当在实例中对引用类型的值进行操作时，很有可能改变原型中的值。（共享问题）
- 2、在创建子类型的实例时，不能向超类型的构造函数中传递参数
默认的原型
- 所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。
如何确定原型和实例之间的关系
- 1、通过instanceof:测试实例与原型链中出现过的构造函数，结果会返回true
alert(instance instanceof Object) //true
alert(instance instanceof SuperType) //true
alert(instance instanceof Subtype) //true
- 2、isPropertyOf()方法：只要是原型链中出现过的原型，都会返回true
alert(Object.prtotype.isPropertyOf(instance)) //true
alert(SuperType.prtotype.isPropertyOf(instance)) //true
alert(Subtype.prtotype.isPropertyOf(instance)) //true
定义方法时要注意的几个问题
- 场景：子类型优势需要覆盖超类型中的某个方法，或者需要添加类型中不存在的某个方法
- 2、不能通过对象字面量方法添加新方法（因为会重写原型链）
- 1、给子类型添加方法的代码一定要放在替换原型的语句之后（否则会因为重新定义了原型而导致添加代码无效）
基本思想：利用原型，让一个引用类型继承另一个引用类型的属性和方法
例子：
function SuperType(){
this.SuperProperty = true;
};
SuperType.prototype.getSuperProperty = function(){return this.SuperProperty};
function SubType(){
this.SubProperty = false;
};
SubType.prototype = new SuperType();
SubType.prototype.getSubProperty = function(){return this.getSubProperty};
var instance = new SubType();
alert(instance.getSuperProperty()) //true
借用构造函数
缺点
- 1、方法都在构造函数中定义，函数无法复用，每个方法都是function的一个新实例
- 2、在超类型的原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式
传递参数
- 优点：借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函数传递参数
function SuperType (name) {function
this.name= name;
}
function SubType () {
//继承了Super'l'ype, 同时还传递了参数
superType.call(this, "Nicholas");
//实例属性
this.age= 29;}
var instance= new SubType();
alert(instance.name) ; //“Nicholas” alert(instance.age); //29
基本思想：在子类型构造函数中调用超类型构造函数
function SuperType(){
this.color = ["red","blue","yellow"]
};
function SubType(){
SuperType.call(this);
};
组合继承
概念
- 1、将原型链和借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式，又叫伪经典继承
- 2、基本思想：使用原型链实现对原型属性和方法的继承，而通过构造函数来实现对实例属性的继承
- 3.是JavaScript中最常用的继承模式
优点：既通过在原型上定义方法实现了函数的复用，又能够保证每个实例都有它自己的属性
组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为javascript中最常用的继承模式
function SuperType(name){
this.name = name;
this.color = ["red","blue","yellow"]
};
SuperType.prototype.sayName = function(){alert(this.name)};
function SubType(name){
SuperType.call(this,name);
this.age = age;
};
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){alert(this.age)};
原型式继承
Object.creat()
- 参数一
- 用作新对象原型的对象
var person = {name:"Nick" ,friends:["Tom","Sam"]};
var anotherPerson =Object.create(person);
- 参数二
- 为新对象定义额外属性的对象（以这种方式指定的任何属性都会覆盖原型对象上的同名属性），注意格式
var person = {name:"Nick" ,friends:["Tom","Sam"]};
var anotherPerson =Object.create(person,{
name:{
value:"Greg"
}
});
- ECMAScipt5通过新增的Object.create()规范化了原型式继承
核心
function object(o){
function F(){};
F.prototype = o;
return new F();
}
例子
var person = {name:"Nick" ,friends:["Tom","Sam"]};
var anotherPerson =object(person);
//person成为了anotherPerson的原型
寄生式继承
寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。
缺点：不能实现函数复用
function creatAnother(original){
var clone = object(original);
clone.sayHi = function(){alert("Hi")};
return clone;
}
在主要考虑对象而不是自定义类型和构造函数的悄况下，寄生式继承也是一种有用的模式。
寄生组合式继承
所谓寄生组合式继承，即通过借用构造函数来继承属性， 通过原型链的混成形式来继承方法。
基本思路： 不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。
目的：解决组合继承模式中调用两次超类型构造函数，导致属性重写，影响性能的问题
- 组合继承例子：
function SuperType(name){ //超类型构造函数
this.name=name;
this.color={"red","blue","green"]
}
SuperType.prototype.sayName=function(){
alert(this.name);
function SubType(name,age){
SuperType.call(this,name) //第二次调用
this.age = age;
}
SubType.prototype = new SuperType(); //第一次调用
SubType.prototype.construtor =SuperType;
SubType.protptype.sayAge =function(){
alert(this.age)
这个例子高效体现在它只调用了一次SuperType的构造函数，并且避免了再prototype上创建不必要的、多余的属性。同时还能保证原型链不变
function inheritPrototype(subType,superType){
//prototype成为superType的一个副本，而不用调用构造函数
var prototype = SuperType.prototype;
prototype.constructor = SubType;
SubType.prototype = prototype;
};
例子
function SuperType(name){
this.name = name;
};
SuperType.prototype.sayName = function(){alert(this.name)};
function SubType(name,age){
SuperType.call(this,name);
this.age = age;
}
inheritPrototype(Subtype,SuperType);
SubType.prototype.sayAge = function(){alert(this.age)};
function inheritPrototype(SubType，SuperType){
var prototype = object(SuperType.prototype);//创建对象
prototype.constructor = subType;//增强对象
subType.prototype = prototype ;//指定对象
}
- 在函数内部，第一步是创建超类型原型的一个副本。第二步是为创建的副本添加constructor屈性，从而弥补因重写原型而失去的默认的constructor属性。最后一步， 将新创建的对象（即副本）赋值给子类型的原型。
网友评论