Lua的面向对象程序设计

Account={balance=0}
function Account.withdraw(self,v)
self.balance=self.balance-v
end

a={balance=0,withdraw=Account.withdraw}
a.withdraw(a,260)

--面向对象语言常使用self参数，lua提供了通过使用冒号操作符来隐藏self参数的声明

function Account:withdraw(v)
self.balance=self.balance-v
end
a:withdraw(100.0)
--冒号的效果相当于在函数定义和函数调用的时候，增加一个额外的隐藏参数
--我们可以使用dot语法定义函数而用冒号语法调用函数，反之亦然，只要我们正确的处理好额外的参数.
--dot语法定义时要加上self参数，调用时要传入相应的对象，冒号语法不用self参数，调用时也不需要相应的参数对象

Lua中对象没有类，每个对象有一个原型prototype，当调用不属于对象的某些操作时，会最先会到prototype中查找这些操作。

Account={balance=0}

function Account:withdraw(v)
self.balance=self.balance-v
end

function Account:deposit(v)
self.balance=self.balance+v
end

function Account:new(o)--返回一个子对象
o=o or {}
setmetatable(o,self)--Account成为o的原型
self.__index=self
return o
end

a=Account:new{balance=0}
print(a.balance)--输出0
a:deposit(100.00)
print(a.balance)--输出100

Account={balance=0}

function Account:withdraw(v)
if v>self.balance then error"insufficient funds" end
self.balance=self.balance-v
end

function Account:deposit(v)
self.balance=self.balance+v
end

function Account:new(o)
o=o or {}
setmetatable(o,self)--Account成为o的原型
self.__index=self
return o
end

SpecialAccount=Account:new()

function SpecialAccount:getLimit()
return self.limit or 0
end
--子类可以重定义从父类中继承来的方法
function SpecialAccount:withdraw(v)
if v-self.balance>=self:getLimit() then
error"insufficeint funds"
end
self.balance=self.balance-v
end

s=SpecialAccount:new{limit=1000.00}

function s:getLimit()
return self.balance*0.1
end

s:withdraw(200.0)--该调用将运行SpecialAccount的withdraw方法，但是当
--方法调用self:getLimit时，最后的定义被触发.

多重继承：将函数用作__index。当一个表的metatable存在一个__index函数时，如果lua调用一个原始表中不存在的函数，Lua将调用这个__index指定的函数，这样可以用__index实现在多个父类中查找子类不存在的域。

--原型，相当于父类
Account={money=0}

function Account:save(v)
self.money=self.money+v
end

function Account:spend(v)
self.money=self.money-v
if self.money<0 then
error"there is not enough money"
end
end

function Account:new(o)
o=o or {}
setmetatable(o,self)
self.__index=self--首先在o的原型中查找，然后在原型的__index中查找
return o
end
--k是缺少的域，plist是table，其元素也是table
function search(k,plist)
for i=1,table.getn(plist) do
local v=plist[i][k]
if v then return v end
end
end

function createClass(...)
local c={}
--__index是函数时，Lua将table和其缺少的域作为参数调用这个函数
setmetatable(c,{__index=function(t,k) print(t,k) return search(k,arg) end})
c.__index=c
function c:new(o)
o=o or {}
setmetatable(o,c)
return o
end
return c
end

Named={}

function Named:getname()
return self.name
end

function Named:setname(s)
self.name=s
end

NamedAccount=createClass(Account,Named)
account=NamedAccount:new{name="paul"}
print(NamedAccount)
print(account:getname())

--[[
table: 0039C988
table: 0039C988    getname
paul
]]

私有性

function newAccount(initialBalance)
--存储在self表中的部分都是私有的
local self={balance=initialBalance}

local withdraw=function(v)
self.balance=self.balance-v
end

local deposit=function(v)
self.balance=self.balance+v
end

local getBalance=function() return self.balance end

return {
withdraw=withdraw,
deposit=deposit,
getBalance=getBalance
}
end

instance=newAccount(100)
print(instance.getBalance())
instance.withdraw(40)
print(instance.getBalance())

single-method的对象实现方法：当对象只有一个单一的方法时，可以将这个单一的方法作为对象返回

function newObject(value)
return function(action,v)
if action=="get" then return value
elseif action=="set" then value=v
else error("invalid action")
end
end
end
--每一个对象是一个单独的闭包，代价比表小得多，这种方式没有继承但有私有性：访问
--对象状态的唯一状态是通过它的内部方法
d=newObject(0)--d这个对象是newObject返回的单一方法
print(d("get"))--0
d("set",10)
print(d("get"))--10