实现继承需要需要了解以下知识足以：


lua __index 元方法函数使用方法。

对表新增字段的__newIndex方法使用。

表的（）调用。
接下来是代码
factory.lua

--默认基类
local BaseObject = require "object"

--构造对象实例
local function _Create(class,inst, ...)
    --递归调用父对象构造
    if class.__base then
        _Create(class.__base, inst, ...)
    end

    --调用本身的构造
    if class.Ctor then
        class:Ctor(inst, ...)
    end
end
--当前系统中存在的类的个数
local ObjectInstanceCount = 0
-- 类工厂继承实现函数
local function Factory(parent, sub, name)
    ObjectInstanceCount = ObjectInstanceCount +1
    if name == nil or name == "" then
        log.Warning("请给你的类输入设置一个有效的名称！")
    end
    local className = name..ObjectInstanceCount
    --父类
    local baseClass = nil
    if parent then
        if parent.__classcreator or rawget(parent, "__class") then
            baseClass = parent.__class
        else
            log.Error("错误的类型继承，请检查！classname="..className)
        end
    end

    if baseClass == nil then
        baseClass = BaseObject
    end
    local subClass = sub or {}
    subClass.__classname = className
    subClass.__base = baseClass
    --子类实例创建器
    local instCreator = {}
    --关联的类名称
    instCreator.__classname = className
    instCreator.__class = subClass
    instCreator.__classcreator=true
    --重写()操作
    setmetatable(instCreator, {
        __call = function(...)
            --子类实例
            local subInst = {
                __classname = className, 		            --类名称
                __class = subClass, 						--类
            }
            --改写子类实例对象的原表，让其从子类或者父类中获取/设置属性、函数
            setmetatable(subInst, {
                --当实例对象中没有的时候，就去子类型中去找，子类型中找不到，就会到父类型中去找
                __index = function(t, k)
                    local v = subClass[k]
                    if not v then
                        local base = subClass.__base
                        while(base) do
                            v = base[k]
                            if v then
                                break
                            end
                            base = base.__base
                        end
                    end
                    rawset(t,k,v)
                    return v
                end,
                --新的属性，都放到之类实例身上
                __newindex = function(t,k,v)
                    rawset(t,k,v)
                end,
            })
            --构造对象
            function subInst:Create(...)
                _Create(subClass, self, ...)
            end
            --返回子类的实例
            return subInst
        end,
    })

    --创建实例
    function instCreator:New(...)
        --创建一个新的对象
        local inst = instCreator()
        --构造
        inst:Create(...)
        return inst
    end
    --返回类工厂
    return instCreator
end
return Factory

object.lua

local Object = {}

function Object:Ctor(...)
end

Object.__class = Object
Object.__classname = "Object"

return Object

parent.lua

local factory = require 'factory'
local Parent = {}
function Parent:Ctor()
    self.age = 14
    print("Parent")
end
return factory(nil,Parent,"Parent")

child.lua

local factory = require 'factory'
local parent = require 'parent'

local Child = {}
function Child:Ctor()
    print('Child')
end

return factory(parent,Child,"Child")

运行test.lua

local child = require 'child'
local inst = child:New()
print(inst.age)

结果：

先使用工厂文件返回一个工厂对象，在使用工厂对象创建某个类型的实例，创建的时候会通过调用__call,使用__index,__newIndex设置parent,返回新对象。