参考文章：
https://blog.csdn.net/linxinfa/article/details/103254828
https://zhuanlan.zhihu.com/p/115159195
https://blog.codingnow.com/cloud/LuaOO
https://blog.codingnow.com/2006/06/oo_lua.html
Lua的面向对象主要是参考云风大神的进行编写，在云风大神源码的基础上考虑了一点细节，构造代码如下：
local _class = {}
function class(super)
local tbClassType = {}
tbClassType.Ctor = false
tbClassType.super = super
tbClassType.New = function(...)
local tbObj = {}
do
local funcCreate
funcCreate = function(tbClass,...)
if tbClass.super then
funcCreate(tbClass.super,...)
end
if tbClass.Ctor then
tbClass.Ctor(tbObj,...)
end
end
funcCreate(tbClassType,...)
end
-- 防止调用Ctor初始化时，在Ctor内部设置了元表的情况发生
if getmetatable(tbObj) then
getmetatable(tbObj).__index = _class[tbClassType]
else
setmetatable(tbObj, { __index = _class[tbClassType] })
end
return tbObj
end
local vtbl = {}
_class[tbClassType] = vtbl
setmetatable(tbClassType, { __newindex =
function(tb,k,v)
vtbl[k] = v
end
})
if super then
setmetatable(vtbl, { __index =
function(tb,k)
local varRet = _class[super][k]
vtbl[k] = varRet
return varRet
end
})
end
return tbClassType
end
baseType = class()
function baseType:Ctor(x)
print("baseType Ctor")
self.x = x
-- do something
-- 包括setmetatable(self,{xxx})
-- 由于在New方法内部已经考虑如果在Ctor函数中设置元表，外部则直接对__index赋值。毕竟一个表只能关联一张元表
end
function baseType:PrintX()
print(self.x)
end
function baseType:Hello()
print('hello baseType')
end
test = class(baseType)
function test:Ctor() -- 定义 test 的构造函数
print("test Ctor")
end
function test:Hello() -- 重载 base_type:hello 为 test:hello
print("hello test")
end
a = test.New(1)
a:PrintX()
a:Hello()
a1 = test.New(2)
a1:PrintX()
a1:Hello()
a:PrintX()
输出结果：
下面对上述代码进行剖析以及注释。上述代码不仅仅实现类的封装以及继承，对元表中的元方法进行重载也已经考虑。
-- 记录所有的类模板以及其对应的方法，同时可以利用在继承关系下快速索引父级属性以及方法。
local _class = {}
-- 构建一个类，返回一个类对象，参数为基类（可不填）
function class(super)
-- 可以理解为构建一个类模板
local tbClassType = {}
-- 构造函数，可以理解为C++的纯虚函数（接口）
tbClassType.Ctor = false
-- 子类记录父类
tbClassType.super = super
-- New成员方法（匿名方法，闭包），只要用于通过类模板实例化一个类对象（实例）
tbClassType.New = function(...)
-- 实例类
local tbObj = {}
do
-- 用于递归调用，如果有基类，且基类有构造函数，那么先调用基类的构造函数；否则直接调用当前类的构造函数
local funcCreate
funcCreate = function(tbClass,...)
if tbClass.super then
-- 如果有基类，优先调用基类的ctor函数（递归，直至没有上一级为止）
funcCreate(tbClass.super,...)
end
if tbClass.Ctor then
-- 调用构造函数
tbClass.Ctor(tbObj,...)
end
end
funcCreate(tbClassType,...)
end
-- 防止调用Ctor初始化时，在Ctor内部设置了元表的情况发生
-- _class[tbClassType]就是类模板绑定的成员，类实例同样需要持有
if getmetatable(tbObj) then
getmetatable(tbObj).__index = _class[tbClassType]
else
setmetatable(tbObj, { __index = _class[tbClassType] })
end
return tbObj
end
-- 这个table保存所有类模板的成员，实现过程中主要保存的是类的成员方法
local vtbl = {}
_class[tbClassType] = vtbl
-- tbClassType 新增成员的时候，存到vtbl中
setmetatable(tbClassType, { __newindex =
function(tb,k,v)
vtbl[k] = v
end
})
if super then
-- 如果当前类继承了父类，那么在访问成员时，如果当前类中不具有该成员，则优先从_class中保存的父级中读取；
-- 然后再将父类的成员赋值给当前类模板的vtbl容器。
-- 简单地说，就似乎如果一个类实例有需要访问的成员则直接调用，否则从该类的上一级查找。
setmetatable(vtbl, { __index =
function(tb,k)
local varRet = _class[super][k]
vtbl[k] = varRet
return varRet
end
})
end
return tbClassType
end
baseType = class()
function baseType:Ctor(x)
print("baseType Ctor")
self.x = x
end
function baseType:PrintX()
print(self.x)
end
function baseType:Hello()
print('hello baseType')
end
test = class(baseType)
function test:Ctor() -- 定义 test 的构造函数
print("test Ctor")
end
function test:Hello() -- 重载 base_type:hello 为 test:hello
print("hello test")
end
a = test.New(1)
a:PrintX()
a:Hello()
a1 = test.New(2)
a1:PrintX()
a1:Hello()
a:PrintX()
上面有些细节的地方需要阅读一下知识点，有助于理解上文代码。
当我们一个表绑定一个元表时，如果为访问表的属性，那么触发的是__index，而如果是修改表的属性，那么触发的是__newindex。也就是说，我们在修改表的属性时并不会遵循__index的查找规则！
tbTest = {}
setmetatable(tbTest,{ __index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
print(key)
end
end})
tbTest.name = "ufgnix0802" -- 这里并不会触发__index这个元方法
print(tbTest.name) -- 触发__index元方法！
getmetatable(tbTest).__newindex = function(mytable, key, value)
rawset(mytable, key, "\""..value.."\"")
end
tbTest.key = "ufgnix0802" -- 触发__newindex元方法！
在lua中，表拥有一个标识：self。self类似于this指针，大多数面向对象语言都隐藏了这个机制，在编码时不需要显示的声明这个参数，就可以在方法内使用this（例如C++和C#）。在lua中，提供了冒号操作符来隐藏这个参数，例如：
local t = {a = 1, b = 2}
function t:Add()
return (self.a + self.b)
end
print(t:Add())
冒号的作用有两个：1. 对于方法定义来说，会增加一个额外的隐藏形参（self）；2. 对于方法调用来说，会增加一个额外的实参（表自身）。
冒号只是一种语法机制，提供的是便利性，并没有引入任何新的东西。使用冒号完成的事情，都可以使用点语法来完成。看下面的例子：
local t = {a = 1, b = 2}
function t:Add()
return (self.a + self.b)
end
function t.Sub(self)
return (self.a - self.b)
end
print(t.Add(t))
print(t:Sub())
从上述我们可以很清楚的知道，‘self’和‘:’配对出现，而我们也可不使用这种方式，但是必须传递类本身。那么关键问题来了，如果方法要调用的方法使用了’:‘符号，但我们又不想使用’:'调用呢？那么是不是我们得传递一个类对象本身？这也是上文代码New函数中funcCreate的调用方式为什么多了一个参数，也就是第一个参数tbClass的原因了。
同时，我们需要留意一个细节，那就是上文代码第30行，我们传入的是tbObj，即我们即将构建的类对象实例的指针，而不是第90行的test对象本身。这也是为什么在第92行打印self 的地址跟test不相等的原因。感兴趣的可以尝试一下，self的地址跟101行的a以及105行的a1相同。
文章链接索引：
https://blog.csdn.net/qq135595696/article/details/128827673