lua中的面向对象模拟，类，继承，多态

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

复制代码

好了一个类定义完毕。现在我们可以开始建立对象了。

1. a = Class:new(10,20)
   
2. a:test()
   
3. b = Class:new(11,23)
   
4. b:test()
   
5. b:plus()
   
6. b:test()

复制代码

结果是

10              20
11              23
12              24

看，两个对象a和b互不影响，并且都可以使用Class的方法，这就是一个类了。
2，继承
LUA之中没有继承的概念，但是可以模拟，我们建立一个新的类Main，它是Class类的子类，包含其一切方法。

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

复制代码

好了然后我们建立对象

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()

复制代码

运行，结果是

20              40              100
21              51              200
20              40              100

明显，他可以运行父类的方法，并且可以重载父类的方法。所以Main继承了Class，为其子类。
3，多态
LUA作为动态语言，支持多态是基本，但是对象呢，这里我们加个方法证明这一点。

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

复制代码

然后在main哪里加入新的定义。

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

复制代码

然后我们开始测试

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())

复制代码

结果是

200
100
200

可见其实LUA也可以使用多态的。
教程讲到这里，这三个东西是游戏脚本上面基本上最为重要的东西，完全证明了，LUA一样可以构建一个完整的游戏脚本，并且因为LUA的特性而言，只会比JAVA这些更加简单而不会更加困难，另外就是LUA语言就是开发来嵌入其他语言中使用的，所以游戏中使用LUA作为脚本是绝对明智的选择。

这里讲一句极为重要的 约定 ，所有人都必须记住，那就是：
调用LUA类的属性请使用点号，而调用其方法请使用冒号，如果你不理解，请百度，但是请谨记。