• 實現(xiàn)方式來源網(wǎng)絡(luò)

function class(base, _ctor)
    local c = {}    -- a new class instance
    if not _ctor and type(base) == 'function' then
        _ctor = base
        base = nil
    elseif type(base) == 'table' then
    -- our new class is a shallow copy of the base class!
    -- 只能繼承全局變量，local變量需要轉(zhuǎn)換為類方法來繼承
        for i,v in pairs(base) do
            c[i] = v
            print(i,v)
        end
        -- c.__index = base
        c._base = base
    end

    -- the class will be the metatable for all its objects,
    -- and they will look up their methods in it.
    c.__index = c

    -- expose a constructor which can be called by <classname>(<args>)
    local mt = {}

    mt.__call = function(class_tbl, ...)
        local obj = {}
        setmetatable(obj,c)
        -- 調(diào)用call的時候調(diào)用構(gòu)造函數(shù)
        if _ctor then
            _ctor(obj,...)
        end
        return obj
    end

    c._ctor = _ctor
    c.is_a = function(self, klass)
        local m = getmetatable(self)
        while m do
            if m == klass then return true end
            m = m._base
        end
        return false
    end
    setmetatable(c, mt)
    return c
end

• 基本使用

require("object")

Animal = class(function( self,name )
    -- 需要繼承的全局變量需要寫到這里，在子類調(diào)用_ctor方法的時候谅猾，加入到子類的table
    self.name = name
    self.s = {}
end)


function Animal:add(key,value)
    -- body
    self.s[key]=value
end
function Animal:get(key)
    -- body
    return self.s[key]
end
-- 執(zhí)行完這段代碼后 Animal中所有數(shù)據(jù)都已經(jīng)拷貝到Cat中赐劣，Animal改變不會引發(fā)Cat改變
-- 如果源碼中不是拷貝Animal中數(shù)據(jù)到Cat中嫉拐，Animal發(fā)生變化。Cat將會跟隨著一直發(fā)生變化
Cat = class(Animal,function( self,name )
    -- body
    Animal._ctor(self,name) --繼承父類構(gòu)造方法(這里是調(diào)用Animal._ctor方法魁兼，參數(shù)是Cat婉徘，name)

end)


cat = Cat("cat") --實例化會調(diào)用_ctor構(gòu)造函數(shù)
cat:add("x","cat")
cat2 = Cat("cat2")
cat2:add("x","cat2")


print(cat:get("x"))

image.png

• 隊列

require("class")
Queue = class(function(self,capacity)
    -- body
    self.capacity = capacity
    self.queue = {}
    self.size = 0
    self.head = -1
    self.rear = -1
end)

function Queue:enQueue(element)
    if not element then return end
    if self.size == 0 then
        self.head = 0
        self.rear = 0
    end
    if self.capacity then
        if self.size >= self.capacity then
            print("隊列已滿")
            return 
        end
        self.rear = (self.rear) % self.capacity + 1
    else
        self.rear = self.rear + 1
    end
    self.queue[self.rear] = element
    self.size = self.size + 1
end


function Queue:deQueue()
    if self.size == 0 then
        print("隊列為空")
        return nil
    end
    if self.capacity then
        self.head = (self.head) % self.capacity + 1
    else
        self.head = self.head + 1
    end
    self.size = self.size - 1
    return self.queue[self.head]
end

• 棧

require("class")
Stack = class(function(self)
    self.stack = {}
end)

function Stack:push(element)
    if not element then return end
    table.insert(self.stack,element)
end

function Stack:pop()
    local len = #self.stack
    if len == 0 then
        print("空棧")
        return nil
    end
    local value = self.stack[len]
    self.stack[len] = nil
    return value
end