Lua的类实现继承、多态以及setmetatable方法

好了，今天开始写下我的一点学些LUA的心得，LUA作为一种世界上广泛使用的游戏脚本语言，有其强大的一面。现在的游戏脚本，基本上都基于面向对象了，因为非面向对象的语言写游戏这种复杂的脚本明显过于麻烦。而LUA不是面向对象的语言，但是为什么会有这么多游戏使用呢？因为LUA之中有强大的table,这个类极为强大，可以当做数组，对象，类，哈希表总之什么都是。。。并且LUA之中具有metatable“元表”这个概念，所以你还可以使用table来构建其他语言的各种数据结构，因为这只是限制了table的功能而已，所以lua的强悍之处在于，它是一种可以自定义数据结构行为的语言，不过这个我们这里不讨论，我们只讨论怎么用LUA模拟其他语言的面向对象特性。

在Lua中实现继承

1，类
类一般都有类名，属性声明，构造体，方法，属性。下面用LUA实现类的模拟，类的模拟有很多种，但是都必须用到__index。这里为了方便只是用一种定式，并且soyomaker的脚本以后也会采用这种定式。

1. --声明，这里声明了类名还有属性，并且给出了属性的初始值。
   
2. Class = {x=0,y=0}
   
3. --这句是重定义元表的索引，就是说有了这句，这个才是一个类。具体的解释，请百度。
   
4. Class.__index = Class
   
5. --构造体，构造体的名字是随便起的，习惯性改为new()
   
6. function Class:new(x,y)
   
7.         local self = {}  --初始化self，如果没有这句，那么类所建立的对象改变，其他对象都会改变
   
8.         setmetatable(self, Class)  --将self的元表设定为Class
   
9.         self.x = x   --属性值初始化
   
10.         self.y = y
    
11.                      return self  --返回自身
    
12. end
    
13. --这里定义类的其他方法
    
14. function Class:test()
    
15.     print(self.x,self.y)
    
16. end
    
17. function Class:plus()
    
18.     self.x = self.x + 1
    
19.     self.y = self.y + 1
    
20. end

复制代码

2：

tab = {}
tab.__index = tab


function tab.new(a, b)
    local t ={}
    t.x = a
t.y = b 


return t;
end


function tab:show()   ---(self)
   print(self.x, self.y)
end


obj = tab:new(3, 5)
obj:show()

他说对象obj是空值  --他说你19行错

因为如果你定义function的时候用的是 .  你的传参第一个必须是对象   ---function tab.new( self,  a,b )  

要不你调用的时候 这样调用     +  tab.new( nil, 3,5 )

1，Lua类实现

从网上搜了几个类实现，自己照猫画老虎的弄个如下：

[cpp]  view plain copy

1. ClassYM = {x=0,y=0}  
2. --这句是重定义元表的索引，必须要有，  
3. ClassYM.__index = ClassYM   
4.   
5. --模拟构造体，一般名称为new()  
6. function ClassYM:new(x,y)  
7.         local self = {}     
8.         setmetatable(self, ClassYM)   --必须要有  
9.         self.x = x     
10.         self.y = y  
11.         return self    
12. end  
13.   
14. function ClassYM:test()  
15.     print(self.x,self.y)  
16. end  
17.   
18. objA = ClassYM:new(1,2)  
19. objA:test()  
20. print(objA.x,objA.y)  

运行结果如下：

1   2
1   2

print(objA:x,objA:y)会报错，调用ojbA.test也会报错，W?

调用

[cpp]  view plain copy

1. objA = ClassYM:new(1,2)  

再调用objA.test()时结果如下：

2  0

如调用

[cpp]  view plain copy

1. objA = ClassYM:new(self,1,2)  

再调用objA.test()时结果如下：

1  2

lua提供了用冒号的方式在一个方法定义中添加一个额外的参数，这个参数就是self，这句话可以不理解，但是要劳记！

继承和多态部分详见：http://www.soyomaker.com/forum.php?mod=viewthread&tid=230

2，继承

[cpp]  view plain copy

1. --声明了新的属性Z  
2. Main = {z=0}  
3. --设置类型是Class  
4. setmetatable(Main, Class)  
5. --还是和类定义一样，表索引设定为自身  
6. Main.__index = Main  
7. --这里是构造体，看，加上了一个新的参数  
8. function Main:new(x,y,z)  
9.    local self = {}  --初始化对象自身  
10.    self = Class:new(x,y) --将对象自身设定为父类，这个语句相当于其他语言的super  
11.    setmetatable(self, Main) --将对象自身元表设定为Main类  
12.    self.z= z --新的属性初始化，如果没有将会按照声明=0  
13.    return self  
14. end  
15. --定义一个新的方法  
16. function Main:go()  
17.    self.x = self.x + 10  
18. end  
19. --重定义父类的方法  
20. function Main:test()  
21.     print(self.x,self.y,self.z)  
22. end  

测试代码如下：

[cpp]  view plain copy

1. c = Main:new(20,40,100)  
2. c:test()  
3. d = Main:new(10,50,200)  
4. d:go()  
5. d:plus()  
6. d:test()  
7. c:test()  

3，多态

[cpp]  view plain copy

1. Class = {x=0,y=0}  
2. Class.__index = Class  
3. function Class:new(x,y)  
4.         local self = {}  
5.         setmetatable(self, Class)  
6.         self.x = x  
7.         self.y = y  
8.                      return self  
9. end  
10. function Class:test()  
11.     print(self.x,self.y)  
12. end  
13. --新定义的一个函数gto()  
14. function Class:gto()  
15.    return 100  
16. end  
17. --这里会引用gto()  
18. function Class:gio()  
19.    return self:gto() * 2  
20. end  
21. function Class:plus()  
22.     self.x = self.x + 1  
23.         self.y = self.y + 1  
24. end  

继承部分代码如下：

[cpp]  view plain copy

1. Main = {z=0}  
2. setmetatable(Main, Class)  
3. Main.__index = Main  
4. function Main:new(x,y,z)  
5.    local self = {}  
6.    self = Class:new(x,y)  
7.    setmetatable(self, Main)  
8.    self.z= z  
9.    return self  
10. end  
11. --重新定义了gto()  
12. function Main:gto()  
13.    return 50  
14. end  
15. function Main:go()  
16.    self.x = self.x + 10  
17. end  
18. function Main:test()  
19.     print(self.x,self.y,self.z)  
20. end  

测试代码如下：

[cpp]  view plain copy

1. a = Class:new(10,20)  
2. print(a:gio())  
3. d = Main:new(10,50,200)  
4. print(d:gio())  
5. print(a:gio())  

具体结果大家可以自己试试看！