javascript 3种继承方式

http://www.mangguo.org/javascript-prototype-constructor-inheritance/

上回说到《JavaScript 原型继承之基础机制》，这一篇将具体说说构造函数的继承。
从一个简单的示例开始，创建描述人类的 People 构造函数：

function People(){
    this.race = '愚蠢的人类';
}

然后，创建描述黄种人的 Yellow 构造函数：

function Yellow(name, skin){
    this.name = name;
    this.skin = skin;
}

要使得黄种人 Yellow 能继承人类 People 对象，在 JavaScript 中可以通过多种方式模拟实现。

1、对象冒充（Object Masquerading）

对象冒充，简单地说就是把一个定义抽象类的构造函数当作常规函数使用，实现伪继承：

function Yellow(name, skin) {
    this._extend = People;
    this._extend();
    delete this._extend; //删除对 People 的引用
    this.name = name;
    this.skin = skin;
}
//实例化 yellow1
var yellow1 = new Yellow('小明', '黄皮肤');
console.log(yellow1.name); //小明
console.log(yellow1.race); //愚蠢的人类

在这段代码中，为 Yellow 添加私有方法 _extend，由于函数本身只是以引用的形式存在，执行时会自动调用 People 方法，并传入 Yellow 构造函数的 name 参数。而 Yellow 对象的自身属性和方法，必须在上述过程结束，清空对外部方法的引用后再进行定义。

注：通过对象冒充可以实现多重继承

2、call / apply 方法

通过 call / apply 方法实现继承可能更为简单，不需要任何繁琐的操作：

function Yellow(name, skin) {
    People.apply(this, arguments);
    this.name = name;
    this.skin = skin;
}
//实例化 yellow2
var yellow2 = new Yellow('大卫', '黑皮肤')
console.log(yellow2.name); //大卫
console.log(yellow2.race); //愚蠢的人类

这里为 apply 传入 arguments 数组，也可以使用 new Array 或字面量数组。

3、原型链（Prototype Chaining）

第一种原型继承方法是把对象的原型指向父类的某个实例：

Yellow.prototype = new People();
Yellow.prototype.constructor = Yellow; //初始的 prototype 被完全清空，所以最好将 constructor 重置
var yellow3 = new Yellow('小王', '黄皮肤');
console.log(yellow3.race); //愚蠢的人类

以上代码可以这样反向理解，yellow3 实例本身找不到 race 属性，而它原型上的 race 属性又恰好是 People 对象的实例的 race 属性。

如果对于 People 对象来说，其属性写入了原型中，则无需实例化，只需将 Yellow 的 prototype 属性指向 People 的 prototype 属性：

function People(){};
People.prototype.race = '愚蠢的人类';
Yellow.prototype = People.prototype;
Yellow.prototype.constructor = Yellow;

这样做不进行实例化操作，只是指针的改变，非常环保。但由于引用类型的关系，Yellow 和 People 指向了同一个原型对象，也就是说对 Yellow.prototype.constructor 的修改实际上破坏了 People 的原型对象。

既然如此，可以借助一个空的中继对象，绕过父类的原型：

var F = function(){};
F.prototype = People.prototype;
Yellow.prototype = new F();
Yellow.prototype.constructor = Yellow;

========================
http://openxtiger.iteye.com/blog/1611259

Javascript对象创建过程：

1.初始化对象

2.将对象的__proto__=类的prototype属性

3.用类构造对象

 

__proto__：为原型链

 

每个对象都会在其内部初始化一个属性，就是__proto__，当我们访问一个对象的属性时，如果这个对象内部不存在这个属性，那么他就会去__proto__里找这个属性，这个__proto__又会有自己的__proto__，于是就这样一直找下去，也就是我们平时所说的原型链的概念。

 

2.将对象的__proto__　=　类的prototype属性，且prototype是一个对象。

 

因此为了实现继承，我们只要将对象的的原型链进行修改即可。

由于__proto__在对象创建后才可出现，其实这个属性也不能直接访问（原则上），但我们在类定义时就得确认类的继承关系。此时，我们突然发现以上加粗的公式。

类的prototype = 对象的 __proto__。好吧，现在只要在类的prototype上做文章即可。

 

可以想象，如果要加入父类的原型链，只有两种方法：

1.将子类的prototype=父类的prototype。这个非常不好，因为既然相等了，此时改变任何一个类的prototype，都会影响另一个类的prototype

2.将子类的prototype=父类的对象。这个是一个不错的想法，修改了类属性时，只是修改父类对象的一个实例，并不会修改父类的类。

然到就这样结束，不会的。为什么不会呢？因为我们在定义类时，并不想让类分配内存，我这类也许只是定义，未必会用，那么以上定义方式就悲剧了，子类的prototype=父类的对象（定义时就创建了父类的对象）。当然创建对象是必须的，可是我们是否可以创建一个不用分配内存（或很少内存）的对象呢，是的，你猜到了，定义一个什么都没有类，比如 var F = function(){};  new F(); 

好了，现在有空对象了，将子类的prototype=new F(); 纳尼？子类只是加入了F的原型链。好吧，我承认我有引导错误的行为，以上的第一种方法（将子类的prototype=父类的prototype）并不是不好，而是要看时机，因为我们害怕它们会相互绑定。但是时机来了，F类，我们并不会修改它任何属性（是的，它只是一个用来做空对象了，谁改了我和谁急）。Year,我们很巧妙的将F.prototype=父类的prototype

 

以上说的太认真了，好吧，其实就是那么简单：

 

var C = function(){}
var P = function(){}
var F = function(){}

C.prototype = new F();
F.prototype = P.prototype;

 以上只是完成了继承的大部分。其实由于类的构造函数被绑在类的prototype上，即prototype.constructor方法。好了，我们既然很粗鲁将子类的prototype移情，好在事情还没发展到需要分手的地步，

我们将子类的prototype.constructor=子类，即 

 

C.prototype.constructor = C;

 好了，既养了小三，又不失原配。我的GOD,i love javascript！

 

继承完成了，来谈一下闭包吧