javascript继承

1, 缺点，给子类prototype添加新方法只能一个一个添加，不能直接传一个对象(方法集合)，否则会覆盖继承的父类的方法。

Function.prototype.inherit = function(baseClass){
    for(var i in baseClass.prototype){
        this.prototype[i] = baseClass.prototype[i];
    }
}
function BaseClass(){}
BaseClass.prototype = {
    method1:function(){
        alert('method1');
    },
    method2:function(){
        alert('method2');
    }
};

function ClassA(){}
ClassA.inherit(BaseClass);
ClassA.prototype.method1 = function(){alert(0);};
var obj = new ClassA();
obj.method1();
var obj2 = new BaseClass();
obj2.method1();

2, 缺点是继承必须Class.prototype = (new BaseClass()).extend({.....});这样写，习惯了java这类面向对象语言的继承的人，估计看着这样的写法会有点别扭，比如我就觉得这样挺别扭的。不过习惯了就好，jquery的继承写法不也跟这样类似么。其实下面这代码就是prototype-1.3.1框架里继承的写法。我按照书上写的。

Object.extend = function(des,source){
    for(var property in source){
        des[property] = source[property];
    }
    return des;
};
Object.prototype.extend = function(object){
    return Object.extend.apply(this,[this,object]);
};

function BaseClass(){
    this.name = "name";
};
BaseClass.prototype = {
    method1:function(){alert('method1');},
    method2:function(){alert('method2');}
};

function Class(){};
Class.prototype = (new BaseClass()).extend({
    method1:function(){alert('extend');},
    m1:function(){alert('m1');},
　  age:'age'
});

var a = new Class();
a.method1();
a.method2();
a.m1();
alert(a.name);

留给自己的问题，如果有谁看到， 并且知道，请告知，谢谢。

这种写法，会将父类构造器里定义的属性也赋给继承类的prototype，即使这些属性的值是undefined，占不占用内存？如果继承时候用apply或者call来继承了基类的属性，如

function BaseClass(name){
    this.name = name;
};
function Class(name,age){
   BaseClass.call(this, name); 
};

然后再用上面的 Class.prototype = (new BaseClass()).extend({.....}); 这个时候，Class有一个name属性，而Class.prototype里应该是也有个name属性，只不过它的值是undefined。在使用的时候，似乎是没有什么问题的，可是我突然想，Class.prototype.name是否会占用一个空间呢？如果占用，这个空间被占用却又没有什么用处,然而这点被占用的空间几乎又并不是很大，是忽略它呢还是应该去优化呢？哎，想到这里，似乎这又并不是一个什么问题了，一个类浪费了这么一点空间，似乎并不是什么大问题。

2014.4.16  补充编辑

接上面的问题，Class.prototype.name是一个属性，自然会占用空间，只不过它指向了window.undefined。这在对Class的对象的属性查找时候，会增加资源消耗。

解决办法：自定义一个prototype对象，将构造函数也定义在prototype对象里，然后用一个通用函数来创建类的实例对象。

如下

//通用创建函数
function New(aClass, aParams)
{
    function new_()
    {
        //调用原型中定义的构造函数，中转构造逻辑及构造参数
        aClass.Create.apply(this,aParams);
    };
    //中转原型对象
    new_.prototype = aClass;
    //返回最终建立的对象，在退出函数体的时候，new_ 函数对象会被释放。
    return new new_();
};
//定义的类(自定义的原型，将类的构造函数放在原型对象里)
var Person = {
    Create:function(name,age)
    {
        this.name = name;
        this.age = age;
    },
    SayHello:function()
    {
        alert("Hello,I'm " + this.name);
    },
    HowOld:function()
    {
        alert(this.name + " is " + this.age + " years old.");
    }
};

//调用通用函数创建对象，并以数组形式传递构造参数
var BillGates = New(Person,["Bill Gates",59]);
BillGates.SayHello();
BillGates.HowOld();

这种写法，很类似于c#的对象语言形式，代码看起来会很优雅。而且这种写法的JavaScript 程序效率会更高。因为其原型对象里既没有了毫无用处的那些对象级的成员，而且还不存在constructor 属性体(新建的对象自己及其原型里没有constructor 属性，返回的是最顶层原型对象的构造函数，即Object)，少了与构造函数间的牵连，但依旧保持了方法的共享性。这让JavaScript 在追溯原型链和搜索属性及方法时，会快捷一些。

用于继承也是一样的，如

//通用的继承方法(自定义的prototype对象)
function Class(aBaseClass, aClassDefine){
    function class_(){
                //Type指向基类
        this.Type = aBaseClass;
        for(var member in aClassDefine){
                        //复制类的全部定义到当前创建的类
            this[member] = aClassDefine[member];
        }
    };
    class_.prototype = aBaseClass;
    return new class_();
}