1.原型链。2.构造函数。3.组合继承。4.寄生组合继承。5.原型式。6.寄生式。
1、简单原型链：
核心：拿父类实例来充当子类原型对象
优点：简单，易于实现
缺点：
① 修改sub1.arr后sub2.arr也变了，因为来自原型对象的 “引用属性” 是所有实例共享的。
②创建子类实例时，无法向父类构造函数传参
function Super(){
this.val = 1;
this.arr = [1];
}
function Sub(){}
Sub.prototype =new Super();// 核心
var sub1 =new Sub();
sub1.val = 2;
sub1.arr.push(2);
alert(sub1.val);// 2
alert(sub1.arr);// 1, 2
var sub2 =new Sub();
alert(sub2.val);// 1
alert(sub2.arr);// 1, 2
2.借用构造函数
核心：借父类的构造函数来增强子类实例，等于是把父类的实例属性复制了一份给子类实例装上了（完全没有用到原型）所有sub1和sub2互不干扰。
优点：（解决了使用原型链继承的缺点，同时引出了以下的缺点）
①解决了子类实例共享父类引用属性的问题
②创建子类实例时，可以向父类构造函数传参
缺点：
无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能，内存爆炸。。
function Super (val){
this.val = val;
this.arr = [1];
this.fun =function(){}
}
function Sub(val){
Super.call(this, val);// 核心
}
实例：
var sub1 =new Sub(1);
var sub2 =new Sub(2);
sub1.arr.push(2);
alert(sub1.val);// 1
alert(sub2.val);// 2
alert(sub1.arr);// 1, 2
alert(sub2.arr);// 1
alert(sub1.fun === sub2.fun);// false
3.组合继承（最常用）
核心：把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点，通过Super.call(this);继承父类的基本属性和引用属性并保留能传参的优点；通过Sub.prototype = new Super();继承父类函数，实现函数复用。
优点：
①不存在引用属性共享问题。
②子类实例可以向父级传参
③函数可以进行复用
缺点:
（一点小瑕疵）子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又是内存浪费，比刚才情况好点，不过确实是瑕疵。
function Super(){
// 只在此处声明基本属性和引用属性
this.val = 1;
this.arr = [1];
}
// 在此处声明函数
Super.prototype.fun1 =function(){};
Super.prototype.fun2 =function(){};
function Sub(){
Super.call(this);// 核心
}
Sub.prototype =new Super();// 核心
var sub1 =new Sub(1);
var sub2 =new Sub(2);
alert(sub1.fun1 === sub2.fun1);// true
4.寄生组合继承（最佳方式）
核心：用beget(Super.prototype);切掉了原型对象上多余的那份父类实例属性
优点：完美了
缺点：理论上没有了（如果用起来麻烦不算缺点的话。。）
用起来麻烦是一方面，另一方面是因为寄生组合式继承出现的比较晚，是21世纪初的东西，大家等不起这么久，所以组合继承是最常用的，而这个理论上完美的方案却只是课本上的最佳方式了
function beget(obj){// 生孩子函数 beget：龙beget龙，凤beget凤。
varF =function(){};
F.prototype = obj;
return new F();
}
function Super(){
// 只在此处声明基本属性和引用属性
this.val = 1;
this.arr = [1];
}
// 在此处声明函数
Super.prototype.fun1 =function(){};
Super.prototype.fun2 =function(){};
//Super.prototype.fun3...
function Sub(){
Super.call(this);// 核心
}
var proto = beget(Super.prototype);// 核心
proto.constructor = Sub;// 核心
Sub.prototype = proto;// 核心
var sub =new Sub();
alert(sub.val);
alert(sub.arr);
5.原型式
核心：用生孩子函数得到得到一个“纯洁”的新对象（“纯洁”是因为没有实例属性），再逐步增强之（填充实例属性）
P.S.ES5提供了Object.create()函数，内部就是原型式继承，IE9+支持
优点：从已有对象衍生新对象，不需要创建自定义类型（更像是对象复制，而不是继承。）
缺点：
① 原型引用属性会被所有实例共享，因为是用整个父类对象来充当了子类原型对象，所以这个缺陷无可避免。
② 无法实现代码复用（新对象是现取的，属性是现添的，都没用函数封装，怎么复用）
function beget(obj){ // 生孩子函数 beget：龙beget龙，凤beget凤。
var F =function(){};
F.prototype = obj;
return new F();
}
function Super(){
this.val = 1;
this.arr = [1];
}
// 拿到父类对象
var sup =new Super();
// 生孩子
var sub = beget(sup);// 核心
// 增强
sub.attr1 = 1;
sub.attr2 = 2;
//sub.attr3...
alert(sub.val);// 1
alert(sub.arr);// 1
alert(sub.attr1);// 1
6.寄生式
这名字太扯了，而且寄生式是一种模式（套路），并不是只能用来实现继承
核心：给原型式继承穿了个马甲而已，看起来更像继承了（上面介绍的原型式继承更像是对象复制）
优点：还是不需要创建自定义类型
缺点：无法实现函数复用（没用到原型，当然不行）
function beget(obj){// 生孩子函数 beget：龙beget龙，凤beget凤。
var F =function(){};
F.prototype = obj;
return new F();
}
function Super(){
this.val = 1;
this.arr = [1];
}
function getSubObject(obj){
// 创建新对象
var clone = beget(obj);// 核心
// 增强
clone.attr1 = 1;
clone.attr2 = 2;
return clone;
}
var sub = getSubObject(newSuper());
alert(sub.val);// 1
alert(sub.arr);// 1
alert(sub.attr1);// 1
