JavaScript中的继承机制

---

1，对象冒充方式

　　原理：构造函数使用this关键字给所有属性和方法赋值。因为构造函数只是一个函数，所有可是基类的构造函数成为子类的方法，然后调用它。子类就会收到基类的构造函数中定义的属性和方法。

　　　　function　ClassA(sColor)　{
　　　　　　　　this.color　=　sColor;
　　　　　　　　this.showColor　=　function()　{
　　　　　　　　　　　alert(this.color);
　　　　　　　　};
　　　　}
　　　　function　ClassB(sColor,sName)　{
　　　　　　　　this.newMethod　=　ClassA;
　　　　　　　　this.newMethod(sColor);
　　　　　　　　delete　this.newMethod;　　//删除对ClassA的引用，以后就不能在调用它。
　　　　　　　　　this.name　=　sName;　　　　　　//所有新的属性和方法必须在删除了新方法（newMethod）的代码后定义.否则，可能会覆盖基类的相关属性和方法
　　　　　　　　　this.showName　=　function()　{
　　　　　　　　　　　　alert(this.name);
　　　　　　　　};
　　　　}
　　　　　　　　
　　　　var　objA　=　new　ClassA("red");
　　　　var　objB　=　new　ClassB("blue","Nicholas");
　　　　objA.showColor();　　　//outputs　"red"
　　　　objB.showColor();　　　//outputs　"blue"
　　　　objB.showName();　　　　//outputs　"Nicholas"

　　并且对象冒充可以支持多重继承。

　　例如

　　　　function　ClassZ(){
　　　　　　　　//继承ClassX
　　　　　　　　this.newMethod　=　ClassX;
　　　　　　　　this.newMethod();
　　　　　　　　delete　this.newMethod;
　
　　　　　　　　//继承ClassY
　　　　　　　　this.newMethod　=　ClassY;
　　　　　　　　this.newMethod();
　　　　　　　　delete　this.newMethod;
　　　　}
但是，如果ClassX和ClassY居右相同名的属性和方法时，ClassY则具有高优先级，因为它从后面的类继承。

　　2，call()方法

　　基本用法:

　　　　function　showColor(sPrefix,　sSuffix)　{
　　　　　　　　alert(sPrefix　+　this.color　+　sSuffix);
　　　　};
　　　　var　obj　=　new　Object();
　　　　obj.color　=　"red";
　　　　showColor.call(obj,　"The　color　is　",　",　a　very　nice　color　indeed.");　//outputs　"The　color　is　red,　a　very　nice　color　indeed."

　　与对象冒充方法一起使用

　　　　function　ClassB(sColor,sName){
　　　　　　　　//this.newMethod　=　ClassA；
　　　　　　　　//this.newMethod(sColor);
　　　　　　　　//delete　this.newMethod;
　　　　　　　　ClassA.call(this,sColor);
　　　　　　　　this.name　=　sName;
　　　　　　　　this.showName　=　function(){
　　　　　　　　　　　　alert(this.name);
　　　　　　　　};
　　　　}

　　3,apply()方法

　　基本用法

　　　　function　display(sPrefix,　sSuffix)　{
　　　　　　　　alert(sPrefix　+　this.color　+　sSuffix);
　　　　}
　　　　var　obj　=　new　Object();
　　　　obj.color　=　"blue";
　　　　display.apply(obj,　new　Array("111",　"222"));

　　同上

　　　　function　ClassB(sColor,　sName)　{
　　　　　　　　ClassA.apply(this,　[sColor]);
　　　　　　　　this.name　=　sName;
　　　　　　　　this.showName　=　function()　{
　　　　　　　　　　　　alert(this.name);
　　　　　　　　};
　　　　}
4,原型链

　　　　function　ClassA()　{
　　　　}
　　　　ClassA.prototype.color　=　"red";
　　　　ClassA.prototype.showColor　=　function(){
　　　　　　　　alert(this.color);
　　　　};
　　　　　　　　
　　　　function　ClassB(){
　　　　}
　　　　　　　　
　　　　ClassB.prototype　=　new　ClassA();
　　　　ClassB.prototype.name　=　"asdf";　//添加新属性和方法必须出现在对ClassB.prototype赋值完成后。
　　　　　ClassB.prototype.showName　=　function(){
　　　　　　　　alert(this.name);
　　　　};
　　　　　　　　
　　　　var　objA　=　new　ClassA();
　　　　var　objB　=　new　ClassB();
　　　　objA.color　=　"red";
　　　　objB.color　=　"blue";
　　　　objB.name　=　"adf";
　　　　objA.showColor();
　　　　objB.showColor();
　　　　objB.showName();

　　注意：调用ClassA的构造函数时，没有给它传递参数。这在原型链中是标准做法。要确保构造函数没有任何参数。

　　原型链不支持多重继承。

　　5，混合方式

　　就是将对象冒充与原型链方式进行组合。

　　　　function　ClassA(sColor)　{
　　　　　　　　this.color　=　sColor;
　　　　}
　　　　ClassA.prototype.showColor　=　function()　{
　　　　　　　　alert(this.color);
　　　　};
　　　　function　ClassB(sColor,　sName)　{
　　　　　　　　ClassA.call(this,　sColor);
　　　　　　　　this.name　=　sName;
　　　　}
　　　　ClassB.prototype　=　new　ClassA();
　　　　ClassB.prototype.showName　=　function()　{
　　　　　　　　alert(this.name);
　　　　};
　　　　var　objA　=　new　ClassA("red");
　　　　var　objB　=　new　ClassB("blue",　"name");
　　　　objA.showColor();
　　　　objB.showColor();
　　　　objB.showName();

　　附：动态原型方法不能实现继承机制。

---

« 
» 

---