0Pricing
Lua Academy · Aula

Métodos de instância e self

Defina métodos usando a sintaxe de dois-pontos e o parâmetro self implícito.

Métodos de instância e self é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

self é a Instância

Quando você chama obj:method(), Lua passa obj automaticamente como o primeiro argumento. Por convenção, esse parâmetro se chama self. Por meio de self, o método acessa os dados da instância e chama outros métodos.

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

Encadeamento de Métodos

Retorne self a partir dos métodos para permitir o encadeamento: obj:method1():method2():method3(). Cada chamada retorna o mesmo objeto, permitindo um estilo fluente. Isso funciona melhor para métodos que modificam o estado.

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

Chamando Outros Métodos

Os métodos podem chamar outros métodos na mesma instância por meio de self:otherMethod(). Isso promove a reutilização de código dentro de uma classe. Os auxiliares privados podem ser funções locais simples que recebem self explicitamente.

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

Aviso sobre Sobrescrita de Métodos

Definir um campo de instância com o mesmo nome de um método de classe oculta o método para essa instância. Geralmente isso é um erro — tenha cuidado quando os nomes dos campos de instância puderem entrar em conflito com os nomes dos métodos.

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 em Retornos de Chamada

Passar um método como retorno de chamada faz com que o self implícito seja perdido. Envolva o método em um fechamento para capturar 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

Métodos Estáticos e de Instância

Um método estático é chamado na classe, não em uma instância. Ele não tem self (ou recebe a classe como self). Em Lua, não há uma distinção formal — por convenção, use . (e não :) para métodos estáticos.

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

Métodos de Mixin

Adicione métodos de uma tabela de mixin a uma classe sem herança formal. Essa é uma composição plana: copie ou referencie as funções do mixin na tabela da classe.

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())

Métodos Abstratos

Lua não impõe métodos abstratos, mas você pode definir um método de classe base que lance um erro, obrigando as subclasses a sobrescrevê-lo. Essa é uma convenção para indicar que o método "deve ser sobrescrito".

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

Tabelas de Métodos

Para classes com muitos métodos, organize-os em grupos por funcionalidade. Todos os métodos na mesma tabela compartilham a mesma busca na metatabela, mas você pode dividi-los por responsabilidade usando subespaços de nomes.

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)

Delegação e Herança

Prefira a delegação (manter uma referência) a cadeias profundas de herança. Uma classe pode delegar para outro objeto em vez de herdar dele, mantendo baixo o acoplamento e cada classe concentrada em sua própria responsabilidade.

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()

Verificação Rápida

Qual é a diferença entre obj:method() e obj.method()?

Revisão: Métodos de Instância

Resumo:

  • Sintaxe de chamada com dois-pontos: obj:method() == obj.method(obj)
  • Retorne self para encadear métodos
  • Chame outros métodos: self:otherMethod()
  • Retornos de chamada: envolva-os em um fechamento para preservar self
  • Métodos estáticos: por convenção, use a notação com ponto
  • Prefira delegação a herança profunda para obter flexibilidade

Perguntas Frequentes

A aula “Métodos de instância e self” é grátis?

Sim — o texto completo de “Métodos de instância e self” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Métodos de instância e self”?

Defina métodos usando a sintaxe de dois-pontos e o parâmetro self implícito. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Métodos de instância e self”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Classes com metatabelas
  2. Construtores e new()
  3. Métodos de instância e self
  4. Encapsulamento com fechamentos
← Voltar para Lua Academy