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.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里边根本就什么都没有,但是只要有一个地方这么调用了,其它的地方继承就可以直接这么写了。