0Pricing
Lua Academy · 课时

使用 __index 链实现单继承

将父类设置为元表的 __index，以继承方法。

使用 __index 链实现单继承 是 CoddyKit 上的免费 Lua Academy 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Lua Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Lua Academy 课程共包含 4 节课。

原型链

单继承通过将子类的 __index 设置为父类来实现。当子类中找不到某个方法时，Lua 会在父类中查找。这就形成了原型链。

local Base={}
Base.__index=Base
function Base.new() return setmetatable({},Base) end
function Base:greet() print("Hello from Base") end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})  -- Child inherits Base

function Child.new() return setmetatable({},Child) end

local c=Child.new()
c:greet()  -- Hello from Base (inherited)

方法解析顺序

在实例上调用方法时：(1) 在实例表中查找；(2) 在 Child 中查找（通过 __index）；(3) 在 Base 中查找（通过 Child 的元表 __index）。第一个匹配项会生效。

local Base={}
Base.__index=Base
function Base:who() print("I am Base") end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:who() print("I am Child") end  -- override

local b=setmetatable({},Base)
local c=setmetatable({},Child)
b:who()  -- I am Base
c:who()  -- I am Child (overrides)

继承构造函数

子类可以通过调用父类构造函数来复用它，也可以定义自己的构造函数，在父类初始化的基础上进行扩展。

local Animal={}
Animal.__index=Animal
function Animal.new(name,sound)
  return setmetatable({name=name,sound=sound},Animal)
end
function Animal:speak() print(self.name..": "..self.sound) end

local Dog={}
Dog.__index=Dog
setmetatable(Dog,{__index=Animal})

function Dog.new(name)
  local self = Animal.new(name,"Woof")
  return setmetatable(self,Dog)
end
function Dog:fetch(item) print(self.name.." fetches "..item) end

local d=Dog.new("Rex")
d:speak(); d:fetch("ball")

检查继承关系

沿着元表链向上遍历，以检查对象的类是否继承自给定基类。这就是 Lua 中 instanceof 的工作方式。

local function instanceof(obj, cls)
  local mt = getmetatable(obj)
  while mt do
    if mt == cls then return true end
    mt = getmetatable(mt)
  end
  return false
end

调用父类方法

通过直接从父类表中访问被覆盖的方法，调用该方法的父类版本。

local Base={}
Base.__index=Base
function Base:init(x) self.x=x end
function Base:value() return self.x end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:init(x,y)
  Base.init(self,x)  -- call parent
  self.y=y
end
function Child:value() return Base.value(self)+self.y end

local c=setmetatable({},Child)
c:init(3,4)
print(c:value())  -- 7

深层继承链

构建三级层次结构：A → B → C。方法查找会遍历完整链条，直到找到目标方法。

local A={}
A.__index=A
function A:aMethod() print("A method") end

local B={}
B.__index=B
setmetatable(B,{__index=A})
function B:bMethod() print("B method") end

local C={}
C.__index=C
setmetatable(C,{__index=B})

local c=setmetatable({},C)
c:bMethod()  -- from B
c:aMethod()  -- from A

覆盖字段

实例可以通过直接设置字段来覆盖类级字段。类字段不会改变，只是对该实例被遮蔽了。

local Creature={}
Creature.__index=Creature
Creature.hp=100
Creature.speed=10

function Creature.new()
  return setmetatable({},Creature)
end

local fast=Creature.new()
fast.speed=20  -- override for this instance

local normal=Creature.new()

print(fast.speed,normal.speed,Creature.speed)  -- 20  10  10

类级继承

设置 setmetatable(Child, {__index=Parent}) 后，类级查找会回退到父类。这意味着如果 Child 没有覆盖方法，Child.classMethod() 就会找到父类上的方法。

local Vehicle={}
Vehicle.__index=Vehicle
Vehicle.maxSpeed=120
function Vehicle.describe() print("Vehicle") end

local Car={}
Car.__index=Car
setmetatable(Car,{__index=Vehicle})

Car.describe()  -- Vehicle (inherited class method)
print(Car.maxSpeed)  -- 120 (inherited class field)

初始化链

为了正确初始化，子类构造函数应调用父类构造函数，以确保父类状态已经建立。沿着继承层次向上进行链式初始化。

local Base={}
Base.__index=Base
function Base:_init(name) self.name=name end

local Mid={}
Mid.__index=Mid
setmetatable(Mid,{__index=Base})
function Mid:_init(name,level)
  Base._init(self,name)
  self.level=level
end

local Top={}
Top.__index=Top
setmetatable(Top,{__index=Mid})
function Top.new(name,level,role)
  local self=setmetatable({},Top)
  Mid._init(self,name,level)
  self.role=role
  return self
end

local t=Top.new("Alice",5,"admin")
print(t.name,t.level,t.role)

抽象基类

创建一个包含未实现方法且会抛出错误的基类。子类必须覆盖这些方法。这会在 Lua 的动态类型系统中强制执行接口契约。

local Serializer={}
Serializer.__index=Serializer
function Serializer:encode(data)
  error(self._type.." must implement encode()",2)
end
function Serializer:decode(str)
  error(self._type.." must implement decode()",2)
end

local JSONSerializer={_type="JSON"}
setmetatable(JSONSerializer,{__index=Serializer})
function JSONSerializer:encode(data)
  return "{"..tostring(data.key).."}"
end

local j=setmetatable({_type="JSON"},JSONSerializer)
print(j:encode({key="val"}))

继承问题

Lua 中的单继承由什么实现？

回顾：单继承

设置 setmetatable(Child, {__index = Parent}) 即可继承方法。__index 链会提供自动委托。要覆盖方法，请在 Child 中定义方法；要调用父类方法，请使用 Parent.method(self) 显式调用。

常见问题解答

「使用 __index 链实现单继承」课时是免费的吗？

是的 — 「使用 __index 链实现单继承」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Lua Academy 课程的其余内容，请升级到 CoddyKit PRO。 Lua Academy 课程共包含 4 节课。

「使用 __index 链实现单继承」这节课中我会学到什么？

将父类设置为元表的 __index，以继承方法。 你通过在浏览器中直接运行的动手代码来练习 Lua Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Lua Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Lua Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。

「使用 __index 链实现单继承」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Lua Academy 课中编写并运行代码吗？

能。每节 Lua Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 使用 __index 链实现单继承
  2. 使用 super 调用父类方法
  3. 混入模式
  4. 方法重写和多态
← 返回 Lua Academy