已经忘了多久没拿起javascirpt的书本了，无聊中拾起快被我遗忘在角落的书本<javascript高级程序设计>。
尼古拉斯竟然把这么奇葩的js面向对象说的这么好
从最原始的工厂模板说起
function createPerson(name,age){
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function(){
console.log(this.name);
}
return o;
}
这样，but...等等，如何知道创建的对象是什么类型的？
构造函数模式
function Person(name,age){
this.name = name;
this.age = age;
this.sayName = function(){
}
var person1 = new Person("三毛",25);
简洁了不少，问题又来了：难道我每次new一个对象，就要重新创建个sayName函数吗？为什么这么说？
函数也是对象，每次实例化Person时，都会实例化一个sayName Function。也就是说：每个Person的示例，都有一个不同的sayName Function实例。何必如此？
理解原型模式
原型模式很好的解决了上述问题，这么说吧，每个function都有一个prototype属性（我们叫原型），指向一个原型对象。
所以，我们可以把公共的方法属性都加到它上面。
function Person(){
}
Person.prototype.name = "三毛";
Person.prototype.age = 25;
Person.prototype.sayName = function(){
console.log(this.name);
}
把属性方法加到了函数的prototype(实际上也是个对象)上，后续创建的实例对象都从这个原型对象上继承了属性和方法。
然而，它也不是完美的。原型对象的问题也是显而易见的：由于所有的实例都是共享原型对象的方法属性，那么意思就是说所有的实例共享了一份属性方法！那创建的实例还有个毛用？
联想到前面我们提过的构造函数模式，我们可以把构造函数+原型模式结合起来。
构造函数负责自有的属性，而原型对象负责公共的方法，一种新的模式应运而生：
组合模式
Person.prototype.sayName = function(){
console.log(this.name);
}
完美解决了构造函数模式和原型模式的问题。
再谈谈javascript继承
在“理解原型模式”中，已经谈到了js的原型模式，而js的继承就是依靠原型链来实现的。
js原型链
我们来简单回顾下前面讲过的内容：
1 每个构造函数都有一个原型对象；
2 原型对象包含一个指向构造函数的指针（证明自己是从哪来的）；
3 构造函数的实例（这么说可能有点不准确）包含一个指向原型对象的指针。
有点晕，感觉有点像三角恋，看个实例：
function SuperType(){
this.property = true;
}
SuperType.prototype.getSuperValue = function(){
return this.property;
}
function SubType(){
this.subproperty = false;
}
//继承，使SubType的原型指向SuperType的原型
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
return this.subproperty;
}
var instance = new SubType();
console.log(instance.getSuperValue());//true,实际上是SuperType的值
看以看出，单独使用原型链实现继承，实际上生成的实例都是共享一份属性或者方法的。
那么，实例就没有意义了。
那如果借用构造函数呢？
我们知道，构造函数只能实现对实例属性的继承，没办法实现方法的继承，所以如果单独使用构造函数模式，方法就需要都写在构造函数里面，函数复用就无从谈起了。
组合继承
组合继承借用了原型链实现原型属性和方法的继承，又可以通过构造函数实现实例属性的继承。可以说既实现了函数复用，又保证每个实例都有自己的属性。
function SuperType(name){
this.name = name;
this.colors = ["red", "blue"];
}
SuperType.prototype.sayName = function(){
console.log(this.name);
}
function SubType(name,age){
SuperType.call(this,name);//在当前实例环境下执行SuperType构造函数->2
this.age = age;
}
SubType.prototype = new SuperType();//->1
SubType.prototype.sayAge = function(){
console.log(this.age);
}
看以看到，这种模式结合了两者的优点，又弥补了相互的不足。可以说，是一种不错的用于实现继承的方法。
但是，这种方法并不是最好的，我们来详细看一下：
1 为了实现继承，第一点调用了SuperType的构造函数，这样SubType.prototype继承了两个属性
2 SubType构造函数内部，又调用了一次SubType构造函数，显得有些多余了
寄生组合继承
通过借用构造函数来继承属性，通过原型链来继承方法。
function object(super){
var func = function(){};
func.prototype = super;
var o = new func();
return o;
}
function inheritPrototype(sub,super){
var prototype = object(super.prototype);
prototype.constructor = sub;
sub.prototype = prototype;
}
这是寄生组合继承的简单形式。
通过接受子构造函数和父构造函数，第一步创建父类型原型的一个副本；
第二步为副本添加constructor属性，最后再把新的原型赋给子原型，完美实现了继承关系。
