javascript几种实现继承方式

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

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

function SuperType () {this.property = true;}SuperType.prototype.getSuperValue = function () {return this.property;};function SubType () {this.subProperty = false;}//继承了SuperTypeSubType.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 () {}//继承了SubTypeSubType.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 () {//继承了SuperTypesuperType.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 ();17var 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().这个是最理想的继承范式。
如图：