js初始点滴

function MyClass(){
    this.ObjFunc = function(){
        console.log("objfunc");
    }
    MyClass.ClassFunc = function(){
        console.log("classfunc");
    }
    MyClass.prototype.ProtoFunc = function(){
        console.log("ProtoFunc");
    }    
}
var obj = new MyClass();
obj.ObjFunc();
obj.ObjFunc.call(MyClass);
MyClass.ClassFunc();
MyClass.ClassFunc.call(obj);
obj.ProtoFunc();
console.log(typeof MyClass.__proto__);
console.log(typeof MyClass.prototype);
console.log(MyClass.__proto__ == MyClass.prototype);
//MyClass.ProtoFunc(); 出错
MyClass.__proto__ = MyClass.prototype;
console.log(MyClass.__proto__ == MyClass.prototype);
MyClass.ProtoFunc();//成功
/*
可以看出JS的原型就是Lua的元表，唯一不同的是，Lua的元表需要一个__index域，而__index域可以指向一个表，所以构建Lua对象的时候，可以这么写
function LuaClass:LuaNew()
    local obj = {}
    setmetatable(obj,self)
    self.__index = self
    return obj
end


function LuaClass:LuaFunc()
    print("LuaFunc")
end
这样，当一个方法既要用于对象，又要用于LuaClass的时候，写起来就比较简单了，不需要这么写
function LuaClass.metatable:LuaFunc()


end
当然这种语法lua也是不支持的
*/
function MyGrander(){
    this.GranderFunc = function(){
        console.log("GranderFunc");
    }
}


function MyFather(){
    this.__proto__  = new MyGrander;
    this.FatherFunc = function(){
        console.log("FatherFunc");
    }
}


function MyChild(){
    this.__proto__ = new MyFather;
    this.ChildFunc = function(){
        console.log("ChildFunc");
    }
}


function MySun(){
    this.__proto__ = new MyChild;
    this.SunFunc = function(){
        console.log("SunFunc");
    }
}
var obj = new MySun();
obj.FatherFunc();
obj.ChildFunc();
obj.SunFunc();
obj.GranderFunc();
obj.SunFunc();
obj.ChildFunc();
obj.FatherFunc();

这种多重继承的方式是可行的，可是有些疑问，为什么this.__proto__被父类构造的时候覆盖了，子类对象仍然可以成功的调用自己的方法，

因为每个类都是用this来给对象赋予方法的，如果想调用子类自己的原型方法，就不行了。

另外，为何必须得new一个父类才可成功继承呢，如果写成this.__proto__ = MyFather.prototype，这样还能成功继承吗，不行，因为此时父类的构造方法还没有

调用，此时父类的prototype里边根本就什么都没有，但是只要有一个地方这么调用了，其它的地方继承就可以直接这么写了。