在lua中，可以通過元表來實現類、物件、繼承等。與元表相關的方法有setmetatable()、__index、getmetatable()、__newindex。

關鍵：實現Lua面向物件可以分解為類的定義和類的例項化兩個問題。類的定義主要是實現繼承，即怎麼讓子類擁有父類的方法集。類的例項化需要解決例項如何共享類的方法集，但獨享自己的成員變數例項。
方案：子類在定義時複製所有基類的方法，在例項化時將該類作為metatable的__index賦值給例項。這就是cocos2dx裡面的lua class的實現。

function clone(object)--clone函式
  local lookup_table = {}--新建table用於記錄
  local function _copy(object)--_copy(object)函式用於實現複製
    if type(object) ~= "table" then 
      return object   ---如果內容不是table 直接返回object(例如如果是數字\字串直接返回該數字\該字串)
    elseif lookup_table[object] then
      return lookup_table[object]--這裡是用於遞迴滴時候的,如果這個table已經複製過了,就直接返回
    end
    local new_table = {}
    lookup_table[object] = new_table--新建new_table記錄需要複製的二級子表,並放到lookup_table[object]中.
    for key, value in pairs(object) do
      new_table[_copy(key)] = _copy(value)--遍歷object和遞迴_copy(value)把每一個表中的資料都複製出來
    end
    return setmetatable(new_table, getmetatable(object))--每一次完成遍歷後,就對指定table設定metatable鍵值
  end
  return _copy(object)--返回clone出來的object表指標/地址
end
--[[
clone  深度克隆一個值。
格式：value = clone(值)
用法示例：
-- 下面的程式碼，t2 是 t1 的引用，修改 t2 的屬性時，t1 的內容也會發生變化
local t1 = {a = 1, b = 2}
local t2 = t1
t2.b = 3    -- t1 = {a = 1, b = 3} <-- t1.b 發生變化
 
-- clone() 返回 t1 的副本，修改 t2 不會影響 t1
local t1 = {a = 1, b = 2}
local t2 = clone(t1)
t2.b = 3    -- t1 = {a = 1, b = 2} <-- t1.b 不受影響
--]]

--Create an class.
function class(classname, super)--super為繼承的類
    local superType = type(super)
    local cls

    --如果父類既不是函式也不是table則說明父類為空
    if superType ~= "function" and superType ~= "table" then
        superType = nil
        super = nil
    end

    --如果父類的型別是函式或者是C物件
    if superType == "function" or (super and super.__ctype == 1) then
        -- inherited from native C++ Object
        cls = {}

        --如果父類是表則複製成員並且設定這個類的繼承資訊
        --如果是函式型別則設定構造方法並且設定ctor函式
        if superType == "table" then  --複製基類變數
            -- copy fields from super
            for k,v in pairs(super) do cls[k] = v end
            cls.__create = super.__create
            cls.super    = super
        else
            cls.__create = super
            cls.ctor = function() end
        end

        --設定型別的名稱
        cls.__cname = classname
        cls.__ctype = 1

        --定義該型別的建立例項的函式為基類的建構函式後複製到子類例項
        --並且呼叫子數的ctor方法
        function cls.new(...)  --例項化
            local instance = cls.__create(...)
            -- copy fields from class to native object
            for k,v in pairs(cls) do instance[k] = v end
            instance.class = cls
            instance:ctor(...)
            return instance
        end

    else
        --如果是繼承自普通的lua表,則設定一下原型，並且構造例項後也會呼叫ctor方法
        -- inherited from Lua Object
        if super then
            cls = {}
            setmetatable(cls, {__index = super})
            cls.super = super
        else
            cls = {ctor = function() end}
        end

        cls.__cname = classname
        cls.__ctype = 2 -- lua
        cls.__index = cls

        function cls.new(...)  --例項化
            local instance = setmetatable({}, cls)
            instance.class = cls
            instance:ctor(...)
            return instance
        end
    end

    return cls
end
 

--宣告一個類：
MyClass = class("MyClass")  
function MyClass:ctor()  
    print("MyClass:ctor()")  
end  
--定義一個物件  
local myclass = MyClass:new()  

--繼承一個類：
--繼承一個函式
GameLayer = class("GameLayer", function()local layer = cc.Layer:create() return layer end)  
local gamelayer = GameLayer:new()
 

ctor=constructor(建構函式)
dtor=destructor(解構函式)

1.在子類建構函式ctor()中要呼叫父類建構函式ctor(),這用self.super:ctor(param)，這句話反應出並不會像C++那樣，在建立子類例項時，自動呼叫父類的建構函式。
2.使用class(classname,super)來子類繼承父類只會繼承父類的成員函式，而不會繼承父類的成員變數。
若要子類既要繼承父類的成員函式也要繼承父類的成員變數，且在建立子類例項時，自動呼叫父類的建構函式。這用下面的class(classname,super)

function class(classname, super)    
    local cls = {}
    if super then
        cls = {}
        for k,v in pairs(super) do cls[k] = v end
        cls.super = super
    else
        cls = {ctor = function() end}
    end

    cls.__cname = classname
    cls.__index = cls

    function cls.new(...)
        local instance = setmetatable({}, cls)
        local create
        create = function(c, ...)
             if c.super then -- 遞歸向上呼叫create
                  create(c.super, ...)
             end
             if c.ctor then
                  c.ctor(instance, ...)
             end
        end
        --create(instance, ...)--若替換成instance:ctor(...)則先呼叫自己的建構函式，若自己沒有，則呼叫父類的建構函式
        instance:ctor(...)
        instance.class = cls
        return instance
    end
    return cls
end

local BaseClass = class("BaseClass", nil)
function BaseClass:ctor(param)
     print("baseclass ctor")
     self._param = param
     self._children = {}
end
function BaseClass:addChild(obj)
     table.insert(self._children, obj)
     for k,v in ipairs(self._children) do
        print(k,v)
     end
end

local DerivedClass = class("DerivedClass", BaseClass)
function DerivedClass:ctor(param)
     print("derivedclass ctor")
end

local instance = DerivedClass.new("param1")
instance:addChild("child1")
--列印輸出
--baseclass ctor
--derivedclass ctor
--1 child1