实例方法和 self
使用冒号语法和隐式 self 参数定义方法。
实例方法和 self 是 CoddyKit 上的免费 Lua Academy 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Lua Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Lua Academy 课程共包含 4 节课。
self 就是实例
调用 obj:method() 时，Lua 会自动将 obj 作为第一个参数传入。按照惯例，这个参数命名为 self。通过 self，方法可以访问实例数据并调用其他方法。
local Counter = {}
Counter.__index = Counter
function Counter.new(start)
return setmetatable({value=start or 0, step=1}, Counter)
end
function Counter:increment()
self.value = self.value + self.step
end
function Counter:getValue() return self.value end
local c = Counter.new(10)
c:increment(); c:increment()
print(c:getValue()) -- 12方法链式调用
让方法返回 self，即可支持链式调用：obj:method1():method2():method3()。每次调用都会返回同一个对象，从而实现流式风格。这最适合用于会修改状态的方法。
local Builder = {}
Builder.__index = Builder
function Builder.new()
return setmetatable({parts={}},Builder)
end
function Builder:add(s) self.parts[#self.parts+1]=s; return self end
function Builder:addAll(t)
for _,v in ipairs(t) do self.parts[#self.parts+1]=v end
return self
end
function Builder:build() return table.concat(self.parts," ") end
local result = Builder.new()
:add("Hello")
:add("from")
:addAll({"Lua","OOP"})
:build()
print(result) -- Hello from Lua OOP调用其他方法
方法可以通过 self:otherMethod() 调用同一实例上的其他方法。这有助于在类中复用代码。私有辅助函数可以是接收 self 作为显式参数的普通局部函数。
local Stack = {}
Stack.__index = Stack
function Stack.new() return setmetatable({_data={},_size=0},Stack) end
function Stack:push(v) self._size=self._size+1; self._data[self._size]=v end
function Stack:pop()
if self:isEmpty() then return nil end
local v=self._data[self._size]; self._data[self._size]=nil
self._size=self._size-1; return v
end
function Stack:peek()
return not self:isEmpty() and self._data[self._size] or nil
end
function Stack:isEmpty() return self._size==0 end
function Stack:size() return self._size end
local s=Stack.new(); s:push(1);s:push(2);s:push(3)
print(s:pop(),s:peek(),s:size()) -- 3 2 2方法覆盖警告
如果为实例设置了一个与类方法同名的实例字段，该字段会遮蔽该实例上的方法。这通常是一个错误——当实例字段名可能与方法名冲突时，请务必小心。
local Dog = {}
Dog.__index = Dog
function Dog.new(n) return setmetatable({name=n},Dog) end
function Dog:speak() print(self.name..": Woof!") end
local d = Dog.new("Rex")
d:speak() -- Rex: Woof!
-- Accidental shadow:
d.speak = "loud" -- now d.speak is a string, not a function
local ok,err = pcall(function() d:speak() end)
print(ok, err) -- false attempt to call a string value回调中的 self
将方法作为回调传递时，会丢失隐式的 self。请将方法包装在闭包中，以捕获 self。
local Timer = {}
Timer.__index = Timer
function Timer.new(n) return setmetatable({count=n},Timer) end
function Timer:tick()
self.count=self.count-1
print("Ticking, count:", self.count)
end
local t = Timer.new(3)
-- Wrong: loses self
-- local cb = t.tick -- cb(t) works but cb() doesn't
-- Correct: closure captures self
local cb = function() t:tick() end
cb(); cb(); cb() -- Ticking 3 times静态方法与实例方法
静态方法是在类上调用的，而不是在实例上调用的。它没有 self（或者接收类作为 self）。在 Lua 中，两者没有正式区别——按照惯例，静态方法使用 . 而不是 :。
local MathUtils = {}
MathUtils.__index = MathUtils
-- Static method (no instance needed)
function MathUtils.clamp(v, lo, hi)
return math.max(lo, math.min(hi, v))
end
-- Instance method (needs self)
function MathUtils:scale(factor)
self.value = self.value * factor
end
print(MathUtils.clamp(15, 0, 10)) -- 10
local m = setmetatable({value=5},MathUtils)
m:scale(3)
print(m.value) -- 15混入方法
可以将混入表中的方法添加到类中，而无需正式继承。这是一种扁平组合：将混入表中的函数复制到类表中，或在类表中引用这些函数。
local Serializable = {}
function Serializable:serialize()
local parts={}
for k,v in pairs(self) do
if type(v)~="function" then
parts[#parts+1]=k.."="..tostring(v)
end
end
return "{"..table.concat(parts,",").."}"
end
local User = {}
User.__index = User
User.serialize = Serializable.serialize -- mixin!
function User.new(n,a) return setmetatable({name=n,age=a},User) end
local u = User.new("Alice",30)
print(u:serialize())抽象方法
Lua 不会强制要求实现抽象方法，但您可以定义一个会抛出错误的基类方法，强制子类覆盖它。这是一种表示“必须覆盖”的约定。
local Shape = {}
Shape.__index = Shape
function Shape.new() return setmetatable({},Shape) end
function Shape:area()
error(type(self).." must implement area()",2)
end
function Shape:describe()
print("Shape area:", self:area())
end
local sq={}
setmetatable(sq,{__index=Shape})
function sq:area() return 4*4 end
sq:describe() -- Shape area: 16方法表
对于包含许多方法的类，可以按功能将方法分组组织。同一表中的所有方法共享相同的元表查找机制，但您可以使用子命名空间按关注点划分它们。
local Entity = {}
Entity.__index = Entity
Entity.Physics = {}
function Entity.Physics:applyForce(fx,fy)
self.vx=(self.vx or 0)+fx
self.vy=(self.vy or 0)+fy
end
Entity.Render = {}
function Entity.Render:draw()
print(string.format("Draw at (%g,%g)",self.x or 0,self.y or 0))
end
-- Mix into main class
for k,v in pairs(Entity.Physics) do Entity[k]=v end
for k,v in pairs(Entity.Render) do Entity[k]=v end
function Entity.new(x,y) return setmetatable({x=x,y=y},Entity) end
local e=Entity.new(10,20); e:draw(); e:applyForce(5,0); print(e.vx)委托与继承
相比深层继承链，优先使用委托（保存引用）。一个类可以将工作委托给另一个对象，而不是继承该对象，从而降低耦合，并让每个类专注于自身职责。
local Logger = {}
Logger.__index = Logger
function Logger.new(name) return setmetatable({name=name},Logger) end
function Logger:log(msg) print("["..self.name.."] "..msg) end
local Service = {}
Service.__index = Service
function Service.new(name)
return setmetatable({
name=name,
logger=Logger.new(name) -- delegation
},Service)
end
function Service:start()
self.logger:log("starting...") -- delegate logging
print(self.name, "running")
end
Service.new("AuthService"):start()快速检查
obj:method() 和 obj.method() 有什么区别？
回顾：实例方法
总结：
- 冒号调用语法：
obj:method()==obj.method(obj) - 返回 self 以支持方法链式调用
- 调用其他方法：
self:otherMethod() - 回调：使用闭包包装，以保留 self
- 静态方法：按照惯例使用点号表示法
- 优先使用委托而非深层继承，以提高灵活性
常见问题解答
「实例方法和 self」课时是免费的吗？
是的 — 「实例方法和 self」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Lua Academy 课程的其余内容，请升级到 CoddyKit PRO。 Lua Academy 课程共包含 4 节课。
「实例方法和 self」这节课中我会学到什么？
使用冒号语法和隐式 self 参数定义方法。 你通过在浏览器中直接运行的动手代码来练习 Lua Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Lua Academy 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Lua Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「实例方法和 self」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Lua Academy 课中编写并运行代码吗？
能。每节 Lua Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。
此课程中的所有课时
- 通过元表实现类
- 构造函数和 new()
- 实例方法和 self
- 使用闭包实现封装