js 面向对象 继承机制

根据w3cschool上的描述：共有3种继承方法（对象冒充，原型链，混合）

1、对象冒充：构造函数ClassA使用this关键字给所有属性和方法赋值，使ClassA构造函数成为ClassB的方法，调用。可实现多重继承。

注意：所有新属性和新方法都必须在删除新方法的代码行后定义，否则会覆盖父类的相关属性和方法，多重继承时存在同名问题。

原始：

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

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

        //新属性和方法
	this.name = sName;
	this.sayName = function(){
		alert(this.name);
	}
}

var objA = new ClassA('blue');
var objB = new ClassB('red', 'jack');

call():function对象的一个方法，它是ECMASript把对象冒充规范化的结果

function ClassB(sColor, sName) {
    //this.newMethod = ClassA;
    //this.newMethod(color);
    //delete this.newMethod;
    ClassA.call(this, sColor);

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

apple():与call类似，第二个参数是数组或arguments（参数对象，两个类中的参数顺序完全一致的话，才可以）

function ClassB(sColor, sName) {
    //this.newMethod = ClassA;
    //this.newMethod(color);
    //delete this.newMethod;
    ClassA.apply(this, new Array(sColor));

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

以上存在内存浪费的问题。那就是对于每个实例对象而言，属性和方法都是一样的，但是每次创建新的实例，都要为其分配新的内存空间，这样做就会降低性能，浪费空间，缺乏效率。

2、原型链：把ClassB的prototype属性设置成ClassA的实例。ClassA的构造函数不能传递参数。

注意：所有新属性和新方法都必须在删除新方法的代码行后定义，否则会覆盖父类的相关属性和方法：因为prototype属性被替换成了新对象，添加了新方法和属性的原始对象将被销毁。

对 ClassB 的所有实例，instanceof 为 ClassA 和 ClassB 都返回 true。对象冒充时不能这样（instanceof是讲类型的，而对象冒充是讲方法的。）。不支持多重继承。

//确保构造函数没有任何参数
function ClassA(){

}
//方法用原型链
ClassA.prototype.color = 'blue';
ClassA.prototype.sayColor = function(){
	alert(this.color);
}

function ClassB(){

}
//把 ClassB 的 prototype 属性设置成 ClassA 的实例
ClassB.prototype = new ClassA();

//新方法和属性
ClassB.prototype.name = '';
ClassB.prototype.sayName = function(){
	alert(this.name);
}

3、混合方式：对象冒充的缺点，每个子类都有与父类相同的方法，这样很占空间；而原型链，子类只是指向父类的方法。但是不能多重继承。所以需要结合起来：对象冒充继承属性；原型链继承方法。

通过对象冒充方式继承时，所有的成员方法都是指向this的，也就是说new之后，每个实例将都会拥有这个成员方法，并不是共用的，这就造成了大量的内存浪费。并且通过对象冒充的方式，无法继承通过prototype方式定义的变量和方法（与我想的一样）

//父类属性用构造函数
function ClassA(sColor) {
    this.color = sColor;
}
//不变的用原型链
ClassA.prototype.sayColor = function () {
    alert(this.color);
};
//子类构造函数用对象冒充继承
function ClassB(sColor, sName) {
    ClassA.call(this, sColor);
    this.name = sName;
}
//方法用原型链继承
ClassB.prototype = new ClassA();
//
ClassB.prototype.constructor = ClassB
//新方法写在最后
ClassB.prototype.sayName = function () {
    alert(this.name);
};

注意：所谓的新属性，在对象冒充中是this.name。在原型链中是prototype.name。

instanceof深入学习

（1）值类型：数值、布尔值、null、undefined。

（2）引用类型：对象、数组、函数。

instanceof为了弥补typeof的不足，作用：实例是否属于某种类型；实例是否属于它的父类型；

新概念：显示原型，隐式原型：新概念，哈哈

真难：http://www.ibm.com/developerworks/cn/web/1306_jiangjj_jsinstanceof/

http://www.alloyteam.com/2015/06/javascript-shu-ju-jie-gou-he-suan-fa-jian-shu-qian-yan/

继承有三种方式：

1、

之前提到的混合方式

2、YUI继承

function Animal() {}
Animal.prototype.feeling = 'happy';

function extend(Child, Parent) {
    var F = function(){};
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
}

extend(Dog, Animal);

var dog = new Dog('二狗', '哈士奇');
print(dog.feeling); // happy

3、jquery继承

function Animal() {}
Animal.prototype.feeling = 'happy';

function deepCopy(Child, Parent) {
    var p = Parent.prototype;
    var c = Child.prototype;
    for (var i in p) {
        if (typeof p[i] === 'object') {
            c[i] = (p[i].constructor === Array) ? [] : {};
            deepCopy(p[i], c[i]);
        } else {
            c[i] = p[i];
        }
    }
}

deepCopy(Dog, Animal);

var dog = new Dog('二狗', '哈士奇');
print(dog.feeling); // happy

看情况用吧。

明白了

混合继承时，为什么要加：ClassB.prototype.constructor = ClassB

这篇教程写的很好，自己现在记录一下：http://www.jb51.net/article/22334.htm

重新覆盖prototype后，这条链上的对象和方法的constructor都变为object，为了纠正，需要把constructor重新定义。

对象继承 一般用混合方式比较好，w3cschool上的例子很清楚。　

YUI的更高效和简洁。