Class 如何使类B用Lua继承类A？

我所知道的是让一门课变成这样：

A=
{
x=0，
y=0，
}
可设置元（A{
__调用=函数（自身、实例）
返回setmetatable（实例，{uuuu index=A}）
结束
})
函数A:foo1（）
返回string.format（'Position（%d，%d'），self.x，self.y）
结束
局部a=a{x=7}--y将是类a中的0
打印（a.x）--打印7
打印（a.y）--打印0

我不想让一个类B继承这个类a。 所以我可以在B类中进行自定义修改，但从A类中获取所有内容

我正在制作一个名为“战场”的事件系统，这将是A级。 有了这些，我打算制作一些迷你游戏，比如“轰炸机人”（继承A类的B类）、吃豆人（继承A类的C类），等等。 我想从“战场”课上得到所有的东西来制作“轰炸机人”和“吃豆人”。 然后在“Bomberman”中进行一些与“Pacman”无关的自定义修改，反之亦然

例如：

B=--B继承A
{
kills=0，
}
--所以B类会有：x，y，kills
C=--C继承A
{
死亡=0，
}
--所以B班有：x，y，死亡

---

继承是使用

\u索引实现的

看

\uu index：索引访问操作表[key]。当表不是表或表中不存在键时，会发生此事件。这个
metavalue在表的metatable中查找。的元值
此事件可以是函数、表或具有
__索引元值。如果它是一个函数，则使用table和key作为参数调用它，并且调用的结果（调整为一个值）
这是手术的结果。否则，最终结果是
使用键对此元值进行索引的结果。这个索引是有规律的，
不是原始的，因此可以触发另一个_索引元值

因此，每当在B中没有实现某些内容时，您可以将索引操作引用到A

我建议你看看这个


您可以将所有内容归结为如下函数：

function CreateClass(...)
  -- "cls" is the new class
  local cls, bases = {}, {...}
  -- copy base class contents into the new class
  for i, base in ipairs(bases) do
    for k, v in pairs(base) do
      cls[k] = v
    end
  end
  -- set the class's __index, and start filling an "is_a" table that contains this class and all of its bases
  -- so you can do an "instance of" check using my_instance.is_a[MyClass]
  cls.__index, cls.is_a = cls, {[cls] = true}
  for i, base in ipairs(bases) do
    for c in pairs(base.is_a) do
      cls.is_a[c] = true
    end
    cls.is_a[base] = true
  end
  -- the class's __call metamethod
  setmetatable(cls, {__call = function (c, ...)
    local instance = setmetatable({}, c)
    -- run the init method if it's there
    local init = instance._init
    if init then init(instance, ...) end
    return instance
  end})
  -- return the new class table, that's ready to fill with methods
  return cls
end

如果你理解了这个片段，你应该知道所有必要的事情。
我正在和我的朋友卡门努沃一起研究这个问题

我们正在寻找可读的和可维护的东西

根据我们对仔猪的回答的理解，这是最终的结果：


函数集类（类，父类）-（类[，父类]）
--类。\u类名称是必需的
assert（class.\uuuu className，“参数'\uuuu className'是必需的。”）
--集合类元表
可设置元（类{
__索引=父类，
__调用=函数（自身、实例）
返回setmetatable（实例，{uuuu index=class}）
结束
})
--附加“is”功能
class[string.format（'is%s'，class.\u className）]=true
结束
A=
{
__className='A'，
x=0，
y=0，
}
setClass（A）
函数A:foo1（）
返回string.format（'Position（%d，%d'），self.x，self.y）
结束
B=
{
__className='B'，
kills=0，
}
setClass（B，A）
函数B:foo2（）
返回string.format（'Kills（%d）'，self.Kills）
结束
C=
{
__className='C'，
死亡=0，
}
setClass（C，A）
函数C:foo3（）
返回string.format（'death（%d'），self.death）
结束
D=
{
__className='D'，
分数=0，
}
setClass（D，C）
函数D:foo4（）
返回string.format（'Points（%d'），self.Points）
结束
函数A:foo5（）
返回“你好”
结束
A.foo='foo'
局部a=a{x=7}
打印（a.x）--打印7
打印（a.y）--打印0
打印（a.kills）--打印为零
印刷品（死亡）——印刷品为零
打印（a.points）--打印零
打印（a:foo1（））--打印位置（7,0）
局部b=b{x=8，y=1}
打印（b.x）--打印8
打印（b.y）--打印1
打印（b.kills）--打印0
打印（b.死亡）--打印为零
打印（b点）--打印零
打印（b:foo1（））--打印位置（8,1）
打印（b:foo2（））--打印杀死（0）
局部c=c{x=9，y=2}
打印（c.x）--打印9
印刷品（c.y）--印刷品2
打印（c.kills）--打印为零
打印（c.死亡）-打印0
打印（c点）--打印零
打印（c:foo1（））--打印位置（9,2）
打印（c:foo3（））--打印死亡（0）
局部d=d{x=10，y=3}
打印（d.x）--打印10张
打印（d.y）--打印3
打印（d.kills）--打印为零
打印（d.d）--打印0
打印（d点）--打印0
打印（d:foo1（））--打印位置（10,3）
打印（d:foo4（））--打印点（0）
打印（a:foo5（））--打印Hello
打印（b:foo5（））--打印Hello
打印（c:foo5（））--打印Hello
打印（d:foo5（））--打印Hello
打印（a.foo）--打印foo
打印（b.foo）--打印foo
打印（c.foo）--打印foo
打印（d.foo）--打印foo
打印（a.isA）——打印为真
打印（a.isB）--打印为零
打印（a.isC）--打印为零
打印（a.isD）--打印为零
打印（b.isA）——打印为真
打印（b.isB）--打印为真
打印（b.isC）--打印为零
打印（b.isD）--打印为零
打印（c.isA）——打印为真
打印（c.isB）--打印为零
打印（c.isC）--打印为真
打印（c.isD）--打印为零
打印（d.isA）——打印为真
打印（d.isB）--打印为零
打印（d.isC）--打印为真
打印（d.isD）--打印为真
你好。我和我的朋友Kamenuvol一起研究这个问题，所以我将公布结果。谢谢你的回答和时间！