Account={balance=}
function Account.withdraw(self,v)
self.balance=self.balance-v
end
a={balance=,withdraw=Account.withdraw}
a.withdraw(a,)
--面向对象语言常使用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=}
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=}
print(a.balance)--输出0
a:deposit(100.00)
print(a.balance)--输出100
Account={balance=}
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
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=} function Account:save(v)
self.money=self.money+v
end function Account:spend(v)
self.money=self.money-v
if self.money< 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=,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()
print(instance.getBalance())
instance.withdraw()
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()--d这个对象是newObject返回的单一方法
print(d("get"))--
d("set",)
print(d("get"))--