使用原型链实现继承
将一个对象赋值给另一个对象的原型，则后者会继承前者的所有属性与方法
如：
function Parent(){
this.age = 23424
}
function Child(){
}
var c = new Child()
alert(c.age) // undefined
Child.prototype = new Parent()
alert(c.age) // undefined
var d = new Child()
alert(d.age) // 23424
第一次出现 undefined ，是因为 Child 中没有定义 age 属性。
在创建对象时，会将 Child.prototype 赋值给 c.__proto__。由于 c 是先于修改 Child 原型创建的，所以 Child.prototype 的重新赋值不会影响 c.__proto__ 指向的对象，因此第二个 alert 时，c.age 依旧是 undefined。
d 是在修改 Child 原型之后创建的， 所以 d.age 就是 Parent 函数中定义 age 属性的值。
缺点
无法为继承的属性设置不同的值——因为属性是所有对象共享的，一旦一个对象修改了值，其余对象的值也会跟着修改。
没有办法在 new 对象时为属性指定不同的值
使用对象冒充实现继承
所谓的对象冒充，就是在子类的构造函数中，调用父类构造函数的 call 方法。
如：
function Parent(age){
this.age = age
}
function Child(age){
Parent.call(this,age) // 调用父类构造函数的 call 方法
}
Parent.prototype.sex = 'f'
var c = new Child('1111')
console.log(c.age) //1111
console.log(c.sex) // undefined
在调用 call 方法时，第一次参数 this 表示的是 Child 的实例对象。
在调用 call 方法时，就相当于在 Child 的对象中调用了 Parent 方法，因此 Parent 方法中的 this 就表示了 Child 的实例对象。所以调用结束后，Child 的实例对象中已经有了 age 属性。
但，使用对象冒充方法，可以在构造时传递参数，又因为没有使用原型，所以也存在共享问题。
缺点
- 如上例如示：对象冒充并不能使子类继承父类原型中的方法属性，所以没办法复用。这因为，对象冒充只是简简单单的在子类对象中调用了父类的构造函数，由父类的构造函数为子类对象添加几个属性、方法而已，跟父类原型没有任何关系。
对象冒充+原型链
使用原型链，可以解决对象冒充时的缺点
如：
function Parent(age){
console.log('Parent()')
this.age = age
}
Parent.prototype.sex = 'f'
function Child(age){
Parent.call(this,age)
}
Child.prototype=new Parent()
var c = new Child('cccc')
console.log(c.sex+","+c.age) // f,cccc
将子类的原型对象设置为父类的一个对象，这样子类就可以继承父类原型中的属性、方法。
缺点
- 父类的构造函数执行两次。第一次用于设置成子类的原型对象；第二次在子类冒充时，子类构造函数中调用 call 方法，引起父类构造函数的再次执行。
临时中转函数实现继承
与原型链一样，只不过将原型链中的一些操作封装到一个函数中。
如：
function create(o){
function F(){}
F.prototype=o;
return new F();
}
var p = {
age:324,
sex:'m'
}
var o = create(p)
console.log(o.sex) //m
缺点
由于它本身是原型链继承的改进，所以原型链继承有的缺点，它也有。
寄生式继承
将临时中转函数与工厂方法结合，就是寄生式继承。
如：
function create(o){
function F(){}
F.prototype=o;
return new F();
}
function obj(o){
var r = create(o);
r.run = function(){
console.log(this.age+","+this.sex)
}
return r;
}
var p = {
age:324,
sex:'m'
}
var o = obj(p)
o.run()
之所以将添加 obj 方法，是为了统一处理新对象的扩展。
第六种方法
使用对象冒充方式继承父类在构造函数中添加的属性、方法；使用原型继承方式，继承父类在原型中添加的属性、方法。
如：
function obj(obj) {
function F(){}
F.prototype = obj;
return new F()
}
function create(parent,child){
var f = obj(parent.prototype) // f 与 parent 共用一个原型
f.constructor= child; // 修改 child 原型中 constructor 的指向
child.prototype = f; // child 的原型为 f，所以 child 可以继承 parent 原型中的属性、方法
}
function Parent(age,num){
this.age = age
this.num = num;
}
Parent.prototype.run = function(){
console.log('this is prototype\'s run --- '+this.age)
}
function Child(age,num){
Parent.call(this,'age','33') // 通过对象冒充方式，使得子对象可以拥有父类的在构造函数中定义的属性、方法
}
create(Parent,Child)
var c = new Child()
console.log(c.age+","+c.num) // 测试父类构造函数中的属性
c.run() // 测试父类原型中的属性与方法
obj方法：返回一个继承参数的对象。该方法的主要目的是将实现继承的逻辑进行封装。外界使用时，只需要调用此方法，而不用考虑怎么实现继承。
create方法：使 parent 与 child 建立继承关系。对外界来说，主要调用的是 create。
child构造函数：通过对象冒充方式，使 child 对象可以继承 parent 构造函数中的属性。