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参数，调用时也不需要相应的参数对象

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时，最后的定义被触发.

--原型，相当于父类

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

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