一，简介

面向对象编程是一种非常流行的计算机编程架构，但是lua 没有具体的类去实现。
先说说面向对象的特征。

1，面向对象特征

1） 封装：指能够把一个实体的信息、功能、响应都装入一个单独的对象中的特性。
2） 继承：继承的方法允许在不改动原程序的基础上对其进行扩充，这样使得原功能得以保存，而新功能也得以扩展。这有利于减少重复编码，提高软件的开发效率。
3） 多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。
4）抽象：抽象(Abstraction)是简化复杂的现实问题的途径，它可以为具体问题找到最恰当的类定义，并且可以在最恰当的继承级别解释问题

2， lua的特性

Lua 最基本的结构是Table ,对象的组成是属性和方法，所以需要用table来描述对象的属性。
function 是lua 中用来定义方法函数的。故此类的实现是可以用lua 的Table + function模拟出来。
继承：可以借助setmetatable（元表）来实现。

3，lua 元表Metatable

lua table 是以键值对的形式存在，如果两表相加，则需要通过元表Metatable进行。
当 Lua 试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫 __add 的字段，若找到，则调用对应的值。 __add 等即时字段，其对应的值（往往是一个函数或是 table）就是"元方法"。
有两个很重要的函数来处理元表：
setmetatable(table,metatable): 对指定 table 设置元表(metatable)，如果元表(metatable)中存在 __metatable 键值，setmetatable 会失败。
getmetatable(table): 返回对象的元表(metatable)。
如：

myTabel = {}
my_metable = {}
setmetatable(myTabel , my_metable )

上述中会将my_metable 表设置为myTabel 的子表（元素）。

__index:
当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表格，Lua会在表格中查找相应的键。
如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。
__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。

mytable = setmetatable({key1 = "value1"}, {
  __index = function(mytable, key)
    if key == "key2" then
      return "metatablevalue"
    else
      return nil
    end
  end
})

print(mytable.key1,mytable.key2)


--- 输出结果 为
value1    metatablevalue


也可以将其简写为
mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)

实例解析：
mytable 表赋值为 {key1 = “value1”}。
mytable 设置了元表，元方法为 __index。
在mytable表中查找 key1，如果找到，返回该元素，找不到则继续。
在mytable表中查找 key2，如果找到，返回 metatablevalue，找不到则继续。
判断元表有没有__index方法，如果__index方法是一个函数，则调用该函数。
元方法中查看是否传入 “key2” 键的参数（mytable.key2已设置），如果传入 “key2” 参数返回 “metatablevalue”，否则返回 mytable 对应的键值。
我们可以将以上代码简单写成：

总结
Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:
1.在表中查找，如果找到，返回该元素，找不到则继续
2.判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。
3.判断元表有没有 __index 方法，如果 __index 方法为 nil，则返回 nil；如果 __index 方法是一个表，则重复 1、2、3；如果 __index 方法是一个函数，则返回该函数的返回值。

__newindex:
此方法是用于对表做更新操作，__index 是用来对表进行访问/
当对表中缺少的索引赋值，解释器会先查找__newindex,如果存在，就调用这个函数而不进行赋值，

mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })

print(mytable.key1) --- value1

mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey) ---nil    新值2

mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)  -----新值1    nil

---

---

lua 表得基本操作符
模式 描述
__add 对应的运算符 ‘+’.
__sub 对应的运算符 ‘-’.
__mul 对应的运算符 ‘*’.
__div 对应的运算符 ‘/’.
__mod 对应的运算符 ‘%’.
__unm 对应的运算符 ‘-’.
__concat 对应的运算符 ‘…’.
__eq 对应的运算符 ‘==’.
__lt 对应的运算符 ‘<’.
__le 对应的运算符 ‘<=’.

-- 自定义计算表中最大键值函数 table_maxn，即返回表最大键值
function table_maxn(t)
    local mn = 0
    for k, v in pairs(t) do
        if mn < k then
            mn = k
        end
    end
    return mn
end

-- 两表相加操作
myTesttable = setmetatable({ 1, 2, 3 }, {
  __add = function(myTesttable , newtable)
    for i = 1, table_maxn(newtable) do
      table.insert(myTesttable , table_maxn(myTesttable )+1,newtable[i])
    end
    return myTesttable 
  end
})

secondtable = {4,5,6}

myTesttable = myTesttable + secondtable
for k,v in ipairs(myTesttable ) do
	print(k,v)
end

---结果如下
1    1
2    2
3    3
4    4
5    5
6    6

回归正题 模仿类得实现

---classname 创建得类名，super继承
function class(classname, super)
    local superType = type(super)
    local cs

    if superType ~= "function" and superType ~= "table" then
        superType = nil
        super = nil
    end
    if superType == "function" or (super and super.__ctype == 1) then
        -- inherited from native C++ Object
        cs = {}

        if superType == "table" then
            -- copy fields from super
            if super ~= nil then
                for k, v in pairs(super) do
                    cs[k] = v
                end
                cs.__create = super.__create
                cs.super = super
            end
        else
            if super then
                cs.__create = super
            end
        end

        cs.ctor = function()
        end
        cs.__cname = classname
        cs.__ctype = 1

        function cs.new(...)
            local instance = cs.__create(...)
            -- copy fields from class to native object
            for k, v in pairs(cs) do
                instance[k] = v
            end
            instance.class = cs
            instance:ctor(...)
            return instance
        end
    else
        -- inherited from Lua Object
        if super then
            cs= clone(super)
            cs.super = super
        else
            cs= {
                ctor = function()
                end
            }
        end

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

        function cs.new(...)
            local instance = setmetatable({}, cs)
            instance.class = cs
            instance:ctor(...)
            return instance
        end
    end

    return cs
end

---

Class的使用

---@class ParentView 
local ParentView = _G.class("ParentView ")
----create----------------------------------------------------------------
function ParentView :create()
    local instance = ParentView :new()
    if nil ~= instance and instance:init() then
        instance:onLoaded("ParentView ")
        return instance
    end
end



----init----------------------------------------------------------------
function ParentView :init()
    return true
end

----onEnter----------------------------------------------------------------
function ParentView :onEnter()
    self:onEvent()
    self:ininView()
end


function ParentView :TestEvent2()
    Log.d("Edric ...test LMBJTEST ...22222222222222222.")
end

--- test 
function ParentView :TestEvent()
    Log.d("Edric ...test LMBJJieBiaoDaTingView ....")
end

function ParentView :onExit()

end

return ParentView 

---

继承

---@class LMBJTEST : ParentView 
local ParentView = require "path" --- 父类得路径
local LMBJTEST = class("LMBJTEST", function()
    local ArmyNode = ParentView :create()
    -- self.superP = ArmyNode
    return ArmyNode
end)
LMBJTEST.__index = LMBJTEST
function LMBJTEST:create()
    local instance = LMBJTEST:new()
    if instance:init() then
        return instance
    end
    return nil
end

function LMBJTEST:init()
    return true
end

--- 重写父类方法， 父类方法的内容 不会直接调用，需全部重写
-- function LMBJTEST:onEnter()
--     self.__create():onEnter()
-- end

function LMBJTEST:TestEvent()
    Log.d("Edric ...test LMBJTEST ....")
    ---- 调用父类方法
    self:TestEvent2()
    
end

return LMBJTEST