javascript几种实现继承方式

许多OO语言都支持二种继承方式：
接口继承和实现继承。
接口继承只继承方法签名，而实现继承则继承实际的方法。
由于JavaScript函数没有签名，在ECMAScript中无法实现接
口继承。
ECMAScript只支持实现继承。
JavaScript中的继承主要是依靠原型链来实现的。
实现继承：
1：原型链
思想：利用原型让一个类型继承另一个引用类型的属性和方法。
每个构造函数都有一个原型对象，原型对象都包含一个指向构造
函数的指针，而实例都包含一个指向原型对象的内部指针。那么，
如果我们让原型对象等于另外一个类型的实例，结果怎么样？
可以很容易的感触，此时的原型对象将包含一个指向另外一个原
型的指针,相应地，另外一个原型中也包含一个指向另一个构
造函数的指针。
假如，另一个原型又是另一个类型的实例，那个上述关系依然成立。
这就是所谓的原型链的基本概念。

实现运行模式的基本模式为：

				function SuperType () {
				this.property = true;
				}
				SuperType.prototype.getSuperValue = function () {
				return this.property;
				};
				function SubType () {
				this.subProperty = false;
				}
				//继承了SuperType
				SubType.prototype = new SuperType ();
				SubType.prototype.getSubValue = function () {
				return this.subProperty;
				};
				var instance = new SubType ();
				alert (instance.getSuperValue);//true

SubType继承了SuperType,而继承是通过创建SuperType的实例，
并将该实例赋值给SubType.prototype实现的。
实现的本质是重写原型对象。
这个例子的实例以及构造函数和原型之间的关系如图：

事实上：上面图片的还少了一个环。所有的应用类型都是默认

继承Object，所有函数的默认原型都是Object的实例，因此默认

原型都会包含一个内部指针，指向Object.prototype。

完整的原型链为：

原型链存在的问题：
原型链虽然很强大，但是存在一些问题，最主要的问题是包含
引用类型的原型。
引用类型的原型属性会被所有的实例共享；这个也是为什么
要在构造函数中，而不是在原型对象中定义属性的原因。
在通过原型来实现继承时，原型实际上会变成另一个类型的实例。
于是，原先的实例属性也就变成了现在的原型属性了。

				function SuperType () {
					this.colors = ["red","blue","green"];
				}
				function SubType () {}
				//继承了SubType
				SubType.prototype = new SuperType ();
				var instance1 = new SubType ();
				instance1.colors.push ("black");
				alert (instance1.colors);//"red,blue,green,black"

				var instance2 = new SubType ();
				alert (instance2.colors);//"red,blue,green,black"

另外一个存在的问题为：
很难为超类型传递参数。
由于这些原因，实践中很少单独使用原型链。
2：借用构造函数(伪造对象或经典继承)
思想：在子类型构造函数的内部调用超类型构造函数(
函数只不过是在特定环境中执行代码的对象，因此可以
通过apply()和call()方法也可以在新创建的对象上执行
构造函数
)。

				function SuperType () {
					this.colors = ["red","blue","green"];
				}
				function SubType () {
					//继承了SuperType
					superType.call (this);
				}
				var instance1 = new SubType ();
				instance1.colors.push ("black");
				alert (instanc1.colors);//"red,blue,green,black"
				
				var instance2 = new SubType ();
				alert (instance2.colors); //"red,blue,green"

通过使用call()方法或者apply()方法，在新创建的SubType实例
下调用了SuperType构造函数，就会在新的SubType对象上执行
SuperType()函数中定义的所有的对象初始化代码，结果，
SubType的每个实例就都具有自己的colors属性的副本了。
优点：
相对于原型链而言，借用构造函数有一个很大的优势，即可以
在子类型构造函数中向超类型构造函数传递参数。

				 function SuperType (name) {
				 	this.name = name;
				 }
				 function SubType (name,age) {
				 	//继承了SuperType，同时还传递了参数
					SuperType.call (this,name);
					this.age = age;
				}
				var instance = new SubType ("a",17);
				alert (instance.name);//"a"
				alert (instance.age);//17

缺点：
如果仅仅是借用构造函数，那么方法都在函数中定义，
方法共享也就无从谈起。而且在超类型原型中定义的方法，
对于子类型是不可见的。由于存在这些问题，借用构造函数
很少单独使用。
3：组合继承
是将原型链和借用构造函数的技术组合到一块的模式。
思想：使用原型链实现对原型属性和方法继承，而通过借用构造
函数来实现实例属性的继承。

				function SuperType (name) {
					this.name = name;
					this.colors = ["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.sayAge = function () {
					alert (this.age);
				};
				var instance1 = new SubType ("a",17);
				instance1.colors.push ("black");
				alert (instance1.colors);//"red,blue,green,black"
				instance1.sayName ();//"a"
				instance1.sayAge ();17
				
				var instance2 = new SubType ("b",21);
				alert (instance2.colors);//"red,blue,green"	
				instance2.sayName();//"b"
				instance2.sayAge ();//21

优点：
避免了原型链和借用构造函数的缺陷，成为JavaScript
中最常用的继承模式。instanceof 和isProprotypeOf()
也能够用于识别基于组合继承创建对象。
缺点：
最大的问题就是无论在什么情况下，都会调用二次超类的
构造函数：一次在创建子类型原型的时候，另一次是在子类
型构造函数内部。子类型最终会包含曹类型对象的全部实例
属性，但是不得不在调用类型构造函数时重写这些属性。

				function SuperType (name) {
					this.name = name;
					this.colors = ["red","blue","green"];
				}
				SuperType.prototype.sayName = function () {
					alert (this.name);
				};
				function SubType (name,age) {
					//继承属性
					SuperType.call (this,name);//第二次调用SuperType()
					this.age = age;
				}
				//继承方法
				SubType.prototype = new SuperType ();//第一次调用SuperType()
				SubType.prototype.sayAge = function () {
					alert (this.age);
				};

第一次调用SuperType构造函数时，SubType.prototype会得到
二个属性：name和colors；它们都是SuperType的实例属性，
只不过位于SubType的原型中。当第二次调用SubType构造函数时，
又会调用一次SuperType构造函数，这次又在新的对象上创建实例
属性name和colors。最终，这二个属性就屏蔽了原型中二个同名的
属性。
图：

4：原型式继承
思想：借助原型可以基于已有的对象创建新对象，同时还不必
因此创建自定义类型。

				function object (O) {
					function F(){}
					F.prototype = o;
					return new F ();
				} 

在object()函数内部，先创建一个临时的构造函数，然后将
传入的对象作为这个构造函数的原型，最后返回这个临时类型
的一个新的实例。从本质上讲，object()对传入其中的对象执行
了一次浅复制。

				var person = {
					name:"zhang",
					friends:["Tom","Lucy"]
				};	
				var anotherPerson = object (person);
				anotherPerson = object(person);
				anotherPerson.name = "Greg";
				anotherPerson.friends.push("lily");
				
				var yetAnotherPerson = object(person);
				yetAnotherPerson.name = "renjiahui";
				yetAnotherPerson.friends.push("Bob");
				alert (person.friends);//"Tom,Lucy,lily,Bob"

5：寄生式继承
思想：创建一个仅用于封装继承过程的函数，该函数
在内部以某种方式来增强对象。

				function createAnother (original) {
					var clone = object (original);//object函数就是4中的函数
					clone.sayHi = function () {
						alert ("hi");
					}
					return clone;
				}

在主要考虑对象而不是自定义类型和构造函数的情况下，
寄生式继承也是一种有用的模式。
前面继承模式使用的object()函数不是必需的；任何
可以返回新的对象的函数都是适用于这个模式。
不可以做到函数复用。
6：寄生组合式继承
思想：通过借用构造函数来继承属性，通过原型链的形式来继承
方法，不必为了指定子类型的原型而调用超类型的构造函数，
我们所需要的无非就是超类型原型的一个副本而已。
本质上，就是使用寄生式继承来继承超类型的原型，然后
再将结果指定给子类型的原型。寄生组合继承基本模式：

				function object (o) {
					function F(){}
					F.prototype = o;
					return new F ();
				} 
				function inheritPrototype (subType,superType) {
					var prototype = object (superType.prototype);//创建对象
					prototype.constructor = subType;
					subType.prototype = prototype;
				}
				function SuperType (name) {
					this.name = name;
					this.colors = ["red","blue","green"];
				}
				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);
				};
				var instance = new SubType ("a",17);
				instance.sayName ();

只调用一次SuperType，并且避免了在SubType.prototype上面创建
不必要的，多余的属性。同时，原型链还可以保持不变，
可以使用instance和isPrototypeOf().这个是最理想的继承范式。
如图：