4.Lua面向对象概念

Lua面向对象概念

Lua面向对象概念
表中的方法

复制表

伪构造

伪继承

伪重写

闭包

1.表中的方法

在Lua的表中，存储的值可以是一个方法。

info = {}
info.uid = function()
print("9206")
end

info.uid()

2.复制表

这里，用一个遍历的方式将一个表格进行复制。

info = {}
info.uid = function()
print("9206")
end
function cloneTable(table)
local temp = {}
for key, var in pairs(table) do
temp[key] = var
end
return temp
end

local newInfo = cloneTable(info)
newInfo.uid()

3.伪“构造”

先介绍两个Lua语法：

..

：表示字符串连接。

x:函数()

:默认把x传进函数里。

info = {}
info.uid = function(newInfo)
print("9206："..newInfo.name)
end
function cloneTable(table)
local temp = {}
for key, var in pairs(table) do
temp[key] = var
end
return temp
end
info.new = function (name)
local self = {}
self = cloneTable(info)
self.name = name
return self
end

local newInfo = info.new("CaMnter")
newInfo:uid()

4.伪“继承”

info = {}
info.uid = function(newInfo)
print("9206："..newInfo.name)
end
function cloneTable(table)
local temp = {}
for key, var in pairs(table) do
temp[key] = var
end
return temp
end
info.new = function (name)
local self = {}
self = cloneTable(info)
self.name = name
return self
end

function extend(child,super)
for key, var in pairs(super) do
child[key] = var
end
end

msg = {1,2,3}
msg.new = function(name)
local temp = info.new(name)
extend(temp,msg)
return temp
end

local m = msg.new("m-CaMnter")
m:uid()

这里，先定义了一个

msg

表格，然后以上述“构造函数”的方式写了一个

new

构造函数，然后调用

info.new(name)

构造函数将实例好的info对象传入自定义的

extend

函数中进行值的复制，最后完成伪“继承”。

5.伪“重写”

跟上面的代码一样，就加了一个msg方法的重写。

info = {}
info.uid = function(newInfo)
print("9206："..newInfo.name)
end
function cloneTable(table)
local temp = {}
for key, var in pairs(table) do
temp[key] = var
end
return temp
end
info.new = function (name)
local self = {}
self = cloneTable(info)
self.name = name
return self
end

function extend(child,super)
for key, var in pairs(super) do
child[key] = var
end
end

msg = {1,2,3}
msg.new = function(name)
local temp = info.new(name)
extend(temp,msg)
return temp
end

msg.uid = function(self)
print("msg uid：9206 "..self.name)
end

local m = msg.new("m-CaMnter")
m.uid(m)

6.闭包

闭包，我的理解就是引用了局部变量的函数。这个被引用的变量将会被外部以这个函数为入口所调用。就相当于

Java

中的

private

属性要设置

setter

和

getter

方法一样。

function info(name)
local object = {}
object.name = name

object.getName = function()
print(object.name)
end

return object
end

function message(name)
local object = info(name)

object.getName = function()
print("message："..object.name)
end
return object
end

local m = message("CaMnter")

for key, var in pairs(m) do
print(key,var)
end
print("********************************")
m:getName()

这里，因为方法message中定义了一个info类型的局部变量

object

，如果直接m.name调用，LDT会直接提示错误，这是就相当于写了

getter

的方法getName函数来获取obejct。