js继承

1.对象冒泡

 关键字this引用的是构造函数当前创建的对象，不过在这个方法中，this指向的是所属的对象把ClassA作为常规的函数来建立继承机制。

function ClassA(sColor)
{
        this.color=sColor;
        this.sayColor=function(){
                   alert(this.color);
        };
}



function ClassB(sColor){
        this.newMethod=ClassA;
        this.newMethod(sColor);
        delete this.newMethod;

        this.name=sName;
        this.sayName=function(){
                     alert(this.name);
        };
}


var objA=new ClassA("red");
var objB=new ClassB("blue","Nicholas");
objA.sayColor();             //outputs "red"
objB.sayColor();             //outputs "blue"
objB.sayName();            //outputs "Nicholas"

2.Call()方法
call()方法的第一个参数用作this的对象，制定方法内部的this指向。

 function ClassB(sColor,sName){
     ClassA.call(this,sColor);
 
 
     this.name=sName;
     this.sayName=function(){
                  alert(this.name);
      };
 }  

3.Apply()方法
apply()方法与call()方法非常类似，只是第二个参数传递的是数组对象。

 function ClassB(sColor,sName){
     ClassA.apply(this,new Array(sColor));
 
 
     this.name=sName;
     this.sayName=function(){
                  alert(this.name);
      };
 }  

同样的，第一个参数仍然为this,第二个参数是只有一个值color的数组。可以把ClassB的整个arguments对象作为第二个参数传递给apply()方法。

 function ClassB(sColor,sName){
     ClassA.apply(this,arguments);
 
 
     this.name=sName;
     this.sayName=function(){
                  alert(this.name);
      };
 }  

当然，只有超类中的参数顺序与子类中的参数顺序完全一致时才可以传递参数对象，如果不一致就要创建一个数组对象，按照正确的顺序放置参数。
4.原型链

function ClassA{}

ClassA.prototype.color="red";
ClassA.prototype.sayColor=function()
{
        alert(this.color);
};

function ClassB(){
}

ClassB.prototype=new ClassA();
ClassB.prototype.name="';
ClassB.prototype.sayName=function()
{            alert(this.name);

};


var objA=new ClassA();
var objB=new ClassB();
objA.color="red";
objB.color="blue';
objB.name="Nicholas";
objA.sayColor();
objB.sayColor();
objB.sayName();

调用ClassA的构造函数时，没有给他传递参数，这在原型链中是标准的做法，要确保构造函数没有任何参数。所有的prototype属性赋值都必须出现在prototype属性被赋值之后，因为在它之前赋值的所有方法都会被删除。因为prototype属性被替换成了新的对象。所以为ClassB类添加name属性和sayName的方法代码如下：

function ClassB（）{}

ClassB.prototype=new ClassA();
ClassB。prototype.name="";
ClassB.prototype.sayName=function(){
          alert(this.name);

};

5混合方式
对象冒泡的方式主要问题是必须使用构造函数方式，上面学过这不是最好的方式。不过如果使用原型链的方式，就无法使用带参数的构造函数。最好的方式是，用构造函数方式定义属性，用原型方式定义方法，这同样适合继承机制，用对象冒充继承构造函数的属性，用原型链继承prototype的方法。

function ClassA(sColor){
            this.color=sColor;
}

ClassA.prototype.sayColor=function(){
            alert(this.color);
};


function ClassB(sColor,sName){
            ClassA.call(this.sColor);
            thi.name=snName;
}

ClassB.prototype=new ClassA();
ClassB.prototype.sayName=function()
{
            alert(this.name);
};


var objA=new ClassA("red");
var objB=new ClassB("blue","Nicholas");
objA.sayColor();
objB.sayColor();
objB.sayName();