1 Account = {}
 2 Account.__index = Account
 3
 4 function Account.create(balance)
 5    local acnt = {}             -- our new object
 6    setmetatable(acnt,Account)  -- make Account handle lookup
 7    acnt.balance = balance      -- initialize our object
 8    return acnt
 9 end
10
11 function Account:withdraw(amount)
12    self.balance = self.balance - amount
13 end
14
15 -- create and use an Account
16 acc = Account.create(1000)
17 acc:withdraw(100)

 1 Account = class(function(acc,balance)
 2               acc.balance = balance
 3            end)
 4
 5 function Account:withdraw(amount)
 6    self.balance = self.balance - amount
 7 end
 8
 9 -- can create an Account using call notation!
10 acc = Account(1000)
11 acc:withdraw(100)

 1 -- animal.lua
 2
 3 require 'class'
 4
 5 Animal = class(function(a,name)
 6    a.name = name
 7 end)
 8
 9 function Animal:__tostring()
10   return self.name..': '..self:speak()
11 end
12
13 Dog = class(Animal)
14
15 function Dog:speak()
16   return 'bark'
17 end
18
19 Cat = class(Animal, function(c,name,breed)
20          Animal.init(c,name)  -- must init base!
21          c.breed = breed
22       end)
23
24 function Cat:speak()
25   return 'meow'
26 end
27
28 Lion = class(Cat)
29
30 function Lion:speak()
31   return 'roar'
32 end
33
34 fido = Dog('Fido')
35 felix = Cat('Felix','Tabby')
36 leo = Lion('Leo','African')
37
38
39
40 D:\Downloads\func>lua -i animal.lua
41 > = fido,felix,leo
42 Fido: bark      Felix: meow     Leo: roar
43 > = leo:is_a(Animal)
44 true
45 > = leo:is_a(Dog)
46 false
47 > = leo:is_a(Cat)
48 true

 1 -- class.lua
 2 -- Compatible with Lua 5.1 (not 5.0).
 3 function class(base, init)
 4    local c = {}    -- a new class instance
 5    if not init and type(base) == 'function' then
 6       init = base
 7       base = nil
 8    elseif type(base) == 'table' then
 9     -- our new class is a shallow copy of the base class!
10       for i,v in pairs(base) do
11          c[i] = v
12       end
13       c._base = base
14    end
15    -- the class will be the metatable for all its objects,
16    -- and they will look up their methods in it.
17    c.__index = c
18
19    -- expose a constructor which can be called by <classname>(<args>)
20    local mt = {}
21    mt.__call = function(class_tbl, ...)
22    local obj = {}
23    setmetatable(obj,c)
24    if init then
25       init(obj,...)
26    else
27       -- make sure that any stuff from the base class is initialized!
28       if base and base.init then
29       base.init(obj, ...)
30       end
31    end
32    return obj
33    end
34    c.init = init
35    c.is_a = function(self, klass)
36       local m = getmetatable(self)
37       while m do
38          if m == klass then return true end
39          m = m._base
40       end
41       return false
42    end
43    setmetatable(c, mt)
44    return c
45 end