继承

由于函数没有签名，在ECMAScript中无法实现接口继承。ECMAScript只支持实现继承，而且其实现继承主要是依靠原型链来实现的。

原型链

其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。
每一个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。

function SuperType(){  
            this.property=true;  
        }  
        SuperType.prototype.getSuperValue=function(){  
            return this.property;  
        }  
        var instance=new SuperType();

如图所示：

实现原型链的基本模式:

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      
        alert(instance instanceof Object);     //true  
        alert(instance instanceof SuperType);  //true  
        alert(instance instanceof SubType);    //true

以上定义了两个类型：SuperType()和SubType()。每个类型分别有一个属性和一个方法。它们的主要区别是SubType继承了SuperType，而继承是通过创建SuperType的实例，并将该实例赋给Subtype.prototype实现的。实现的本质是重写原型对象，代之以一个新类型的实例，也就是说原来存在于SuperType的实例重的所有属性和方法，现在也存在于SubType.prototype中了。在确定了继承关系之后，我们给SubType.prototype添加了一个方法，这样就在继承了SuperType的属性和方法的基础上又添加了一个新方法。
其图形表示：

从图中的表示中可以看出来：instance指向SubType.prototype，SubType.prototype又指向了SuperType.prototype。
故原型链的搜索步骤是：1）搜索实例；2）搜索SubType.prototype；3）搜索SuperType.prototype，最后一步才会找到该方法。

默认原型

事实上，我们的原型链还少了一环，所有引用类型默认继承了Object类型，而这个继承也是通过原型链实现的。我们要记住，所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。这也正式自定义类型能使用toString()等默认方法的原因。

一句话，SubType集成了SuperType，而SuperType继承了Object。当调用instance.toSring()时，实际调用的是保存在Object.prototype中的那个方法。

确定原型和实例的关系

可以使用instanceof操作符来测试实例与原型链中出点过的构造函数。

alert(instance instanceof Object);     //true 
alert(instance instanceof SuperType);  //true 
alert(instance instanceof SubType);    //true

谨慎的定义方法

子类型有时需要重写父类型中的某个方法，或者需要添加父类型中不穿在的某个方法，但不管怎么，给原型添加的代码一定要放在替换原型的语句之后。

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; 
    }   
//**重写父类型中的方法** 
SubType.prototype.getSuperValue=function(){ 
    return false; 
    }   
var instance=new SubType(); 
alert(instance.getSuperValue());         //false

注意，在通过原型链实现继承时，不能使用对象字面量创建原型对象，这样会重写原型链。

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; 
        }, 
    someOtherMethod:function(){ 
        return false; 
        }          
    } 
var instance=new SubType(); 
alert(instance.getSuperValue());         //error

由于现在的原型包含的是一个Object的实例，而非SuperType的实例，因此我们设想中的原型链已经别切断——SubType和SuperType已经没关系了。

原型链的问题

​原型链最主要的问题还是来支援引用类型的原型，我们以前说过包含引用类型值的原型属性会被所有实例共享，这也是为什么要在构造函数中定义属性，而不是在原型中定义属性的原因了。在通过原型来实现继承时，原型实际上会被变成另一个类型的实例。

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

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

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

原型的第二个问题：在创建子类的实例时，不能向父类型的构造函数草地参数，所以实践中很少单独用到原型链。