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

来源：互联网发布：unity3d 建筑模型素材编辑：程序博客网时间：2024/06/10 17:25

之前实习做项目的时候项目用到lua方面的知识，不过自己实在太菜，现在也一样，没办法也没时间接触到lua面向对象的内容（囧）。现在上网找了点资料，做下笔记：

首先了解下Metatable，原文链接：http://www.cnblogs.com/simonw/archive/2007/01/17/622032.html，下面是原文：

什么是Metatable

Lua中Metatable这个概念, 国内将他翻译为元表. 元表为重定义Lua中任意一个对象(值)的默认行为提供了一种公开入口. 如同许多OO语言的操作符重载或方法重载. Metatable能够为我们带来非常灵活的编程方式.

具体的说, Lua中每种类型的值都有都有他的默认操作方式, 如, 数字可以做加减乘除等操作, 字符串可以做连接操作, 函数可以做调用操作, 表可以做表项的取值赋值操作. 他们都遵循这些操作的默认逻辑执行, 而这些操作可以通过Metatable来改变. 如, 你可以定义2个表如何相加等.

看一个最简单的例子, 重定义了2个表的加法操作. 这个例子中将c的__add域改写后将a的Metatable设置为c, 当执行到加法的操作时, Lua首先会检查a是否有Metatable并且Metatable中是否存在__add域, 如果有则调用, 否则将检查b的条件(和a相同), 如果都没有则调用默认加法运算, 而table没有定义默认加法运算, 则会报错.

--定义2个表a = {5, 6}b = {7, 8}--用c来做Metatablec = {}--重定义加法操作c.__add = function(op1, op2)   for _, item in ipairs(op2) do      table.insert(op1, item)   end   return op1end--将a的Metatable设置为csetmetatable(a, c)--d现在的样子是{5,6,7,8}d = a + b

有了个感性的认识后, 我们看看Metatable的具体特性.

Metatable并不神秘, 他只是一个普通的table, 在table这个数据结构当中, Lua定义了许多重定义这些操作的入口. 他们均以双下划线开头为table的域, 如上面例子的__add. 当你为一个值设置了Metatable, 并在Metatable中设置了重写了相应的操作域, 在这个值执行这个操作的时候就会触发重写的自定义操作. 当然每个操作都有每个操作的方法格式签名, 如__add会将加号两边的两个操作数做为参数传入并且要求一个返回值. 有人把这样的行为比作事件, 当xx行为触发会激活事件自定义操作.

Metatable中定义的操作
add, sub, mul, div, mod, pow, unm, concat, len, eq, lt, le, tostring, gc, index, newindex, call...

在Lua中任何一个值都有Metatable, 不同的值可以有不同的Metatable也可以共享同样的Metatable, 但在Lua本身提供的功能中, 不允许你改变除了table类型值外的任何其他类型值的Metatable, 除非使用C扩展或其他库. setmetatable和getmetatable是唯一一组操作table类型的Metatable的方法.

Metatable与面向对象

Lua是个面向过程的语言, 但通过Metatable可以模拟出面向对象的样子. 其关键就在于__index这个域. 他提供了表的索引值入口. 这很像重写C#中的索引器, 当表要索引一个值时如table[key], Lua会首先在table本身中查找key的值, 如果没有并且这个table存在一个带有__index属性的Metatable, 则Lua会按照__index所定义的函数逻辑查找. 仔细想想, 这不正为面向对象中的核心思想继承, 提供了实现方式么. Lua中实现面向对象的方式非常多, 但无论哪种都离不开__index.

这个例子中我使用了Programming In Lua中的实现OO的方式, 建立了Bird(鸟)对象, 拥有会飞的属性, 其他鸟对象基于此原型, Ostrich(鸵鸟)是鸟的一种但不会飞. 结果很明显, Bird和Ostrich分别有独立的状态.

local Bird = {CanFly = true}function Bird:New()    local b = {}    setmetatable(b, self)    self.__index = self    return bendlocal Ostrich = Bird:New() --Bird.CanFly is true, Ostrich.CanFly is trueOstrich.CanFly = false --Bird.CanFly is true, Ostrich.CanFly is false

__newindex与__index相对应, 在对table的key做更新时触发. 可以使用rawset和rawget对table的key操作来跳过这些事件的触发.

调用与截获

Java与C#中需要费不少周折来实现动态代理和AOP, 类似这样的功能在Lua中确很简单, 虽然被限制了很多, 但你依然能够感受到Lua的灵活. 这就是__call操作, 当值被调用时触发.

这里我将table类型的a做了一个函数方式的调用a(), 会触发__call. 另一个应用示例可以参见我的另一篇文章Lua中实现类似C#的事件机制

a = {}function a:Func()   print("simonw")endc = {}c.__call = function(t, )   print("Start")   t.Func()   print("End")endsetmetatable(a, c)a()--[[StartsimonwEnd]]

这里的示例都是以最简单的方式展现, 以便能更清晰的描述核心, 更多的资料以及具体应用请参考Programming In Lua和Lua参考手册.

华丽的分割线

————————————————————————————————————————————————————————————————————————————

下面来看lua中的面向对象模拟，类，继承，多态，原文链接：http://blog.sina.com.cn/s/blog_6b9d508001015qd3.html，如下：

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

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

复制代码

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

a = Class:new(10,20)
a:test()
b = Class:new(11,23)
b:test()
b:plus()
b:test()

复制代码

结果是

10        20
11        23
12        24

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

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

复制代码

好了然后我们建立对象

c = Main:new(20,40,100)
c:test()
d = Main:new(10,50,200)
d:go()
d:plus()
d:test()
c:test()

复制代码

运行，结果是

20        40        100
21        51        200
20        40        100

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

Class = {x=0,y=0}
Class.__index = Class
function Class:new(x,y)
local self = {}
setmetatable(self, Class)
self.x = x
self.y = y
return self
end
function Class:test()
print(self.x,self.y)
end
--新定义的一个函数gto()
function Class:gto()
return 100
end
--这里会引用gto()
function Class:gio()
return self:gto() * 2
end
function Class:plus()
self.x = self.x + 1
self.y = self.y + 1
end

复制代码

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

Main = {z=0}
setmetatable(Main, Class)
Main.__index = Main
function Main:new(x,y,z)
local self = {}
self = Class:new(x,y)
setmetatable(self, Main)
self.z= z
return self
end
--重新定义了gto()
function Main:gto()
return 50
end
function Main:go()
self.x = self.x + 10
end
function Main:test()
print(self.x,self.y,self.z)
end

复制代码

然后我们开始测试

a = Class:new(10,20)
print(a:gio())
d = Main:new(10,50,200)
print(d:gio())
print(a:gio())

复制代码

结果是

200
100
200

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

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

好了就到这里了。

0 0