0Pricing
Lua Academy · Aula

Sobrescrita e polimorfismo

Sobrescreva métodos da classe-pai e obtenha despacho polimórfico em tempo de execução.

Sobrescrita e polimorfismo é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 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.

Sobrescrita de Métodos

Uma classe-filha sobrescreve um método da classe-pai definindo um método com o mesmo nome. Quando chamado em uma instância filha, é executada a versão da filha. A versão da classe-pai continua acessível por meio de Parent.method(self).

local Shape={} Shape.__index=Shape
function Shape:area() return 0 end
function Shape:describe() print(type(self).." area="..self:area()) end

local Circle={} Circle.__index=Circle
setmetatable(Circle,{__index=Shape})
function Circle.new(r) return setmetatable({r=r},Circle) end
function Circle:area() return math.pi*self.r^2 end

local Square={} Square.__index=Square
setmetatable(Square,{__index=Shape})
function Square.new(s) return setmetatable({s=s},Square) end
function Square:area() return self.s^2 end

Circle.new(5):describe()
Square.new(4):describe()

Despacho Polimórfico

Polimorfismo: tipos diferentes de objetos respondem de maneiras diferentes à mesma mensagem. Uma função que aceita qualquer “forma” e chama :area() funciona para qualquer tipo de forma — cada um responde com sua própria implementação.

local shapes={
  Circle.new(3),
  Square.new(4),
  Circle.new(1),
}

local total=0
for _,shape in ipairs(shapes) do
  total=total+shape:area()
end
print(string.format("Total area: %.2f",total))

Tipagem por Pato

Lua usa tipagem por pato: se um objeto possui o método, ele funciona. Não é necessária uma declaração formal de interface. Uma função que chama :speak() funciona com qualquer objeto que tenha um método speak, independentemente da classe.

local function makeNoise(obj)
  if type(obj.speak)=="function" then
    obj:speak()
  else
    print("(silent)")
  end
end

local Duck={speak=function(self) print("Quack!") end}
local Robot={speak=function(self) print("Beep boop!") end}
local Rock={}

makeNoise(Duck)   -- Quack!
makeNoise(Robot)  -- Beep boop!
makeNoise(Rock)   -- (silent)

Polimorfismo de Operadores

Metamétodos como __add permitem o polimorfismo de operadores. Tipos diferentes podem responder a + com sua própria semântica, desde que definam __add.

local Vec2={} Vec2.__index=Vec2
Vec2.__add=function(a,b) return Vec2.new(a.x+b.x,a.y+b.y) end
Vec2.__tostring=function(v) return "("..v.x..","..v.y..")" end
function Vec2.new(x,y) return setmetatable({x=x,y=y},Vec2) end

local Color={} Color.__index=Color
Color.__add=function(a,b)
  return Color.new(math.min(255,a.r+b.r),math.min(255,a.g+b.g),math.min(255,a.b+b.b))
end
function Color.new(r,g,b) return setmetatable({r=r,g=g,b=b},Color) end

print(tostring(Vec2.new(1,2)+Vec2.new(3,4)))  -- (4,6)

Padrão Visitante

O padrão visitante separa as operações dos objetos. Uma operação “visita” objetos de tipos diferentes, chamando o método apropriado com base no tipo. Use-o para operações que precisam variar conforme o tipo sem modificar os tipos.

local function printInfo(obj)
  local mt = getmetatable(obj)
  if mt == Circle then
    print(string.format("Circle r=%.1f area=%.2f",obj.r,obj:area()))
  elseif mt == Square then
    print(string.format("Square s=%.1f area=%.2f",obj.s,obj:area()))
  end
end
for _,s in ipairs({Circle.new(3),Square.new(4)}) do
  printInfo(s)
end

Tabela de Interface

Defina uma interface como uma tabela de nomes de métodos. Valide se um objeto implementa todos os métodos necessários antes de usá-lo de forma polimórfica.

local function implements(obj, interface)
  for _, method in ipairs(interface) do
    if type(obj[method]) ~= "function" then
      return false, "missing: "..method
    end
  end
  return true
end

local Drawable = {"draw","resize","move"}

local Widget = {
  draw=function(self) print("draw "..self.type) end,
  resize=function(self,w,h) self.w,self.h=w,h end,
  move=function(self,x,y) self.x,self.y=x,y end,
  type="button"
}

local ok,err = implements(Widget,Drawable)
print(ok,err)  -- true nil

Verificação da Existência de Método

Antes de chamar opcionalmente um método de forma polimórfica, verifique se o objeto o possui. Isso permite capacidades opcionais sem exigir uma classe-base comum.

local function maybeUpdate(obj, dt)
  if type(obj.update)=="function" then
    obj:update(dt)
  end
end

local objects={
  {x=0,y=0,update=function(self,dt) self.x=self.x+10*dt end},
  {x=0,y=0},  -- no update
  {x=0,y=0,update=function(self,dt) self.y=self.y+5*dt end},
}

for _,o in ipairs(objects) do maybeUpdate(o,1) end
for _,o in ipairs(objects) do print(o.x,o.y) end

Tabela de Despacho por Tipo

Em vez de cadeias de if/elseif, use uma tabela de despacho: associe nomes de tipos a funções manipuladoras. Este é o padrão de polimorfismo orientado por tabela.

local handlers={
  number  = function(v) return "num:"..v end,
  string  = function(v) return "str:\"".."..v.."\"" end,
  boolean = function(v) return "bool:"..(v and "T" or "F") end,
  table   = function(v) return "tbl:#"..tostring(#v) end,
}

local function describe(v)
  local h=handlers[type(v)]
  return h and h(v) or "unknown"
end

print(describe(42))
print(describe("hello"))
print(describe({1,2,3}))

Retornos Covariantes

Métodos da classe-filha podem retornar tipos mais específicos que os métodos da classe-pai (retorno covariante). Como Lua tem tipagem dinâmica, isso é natural — uma fábrica da filha retorna uma instância filha, não apenas uma instância da classe-pai.

local Base={} Base.__index=Base
function Base.new() return setmetatable({type="base"},Base) end
function Base:copy() return Base.new() end

local Child={} Child.__index=Child
setmetatable(Child,{__index=Base})
function Child.new(extra)
  local self=setmetatable({type="child"},Child)
  self.extra=extra; return self
end
function Child:copy() return Child.new(self.extra) end  -- covariant

local c=Child.new("hello")
local c2=c:copy()
print(c2.extra,getmetatable(c2)==Child)  -- hello true

Resumo do Polimorfismo

Polimorfismo em Lua na prática: o mesmo nome de método, com comportamento diferente para cada tipo. Isso é obtido por meio de OOP baseada em metatabelas, verificações de tipagem por pato ou tabelas de despacho. Não é necessário um sistema formal de interfaces — basta manter convenções consistentes de nomenclatura de métodos.

-- Three ways to achieve polymorphism:
-- 1. Metatable inheritance + method override
-- 2. Duck typing: just call it if it exists
-- 3. Dispatch table: map type -> handler

local function area(shape)
  -- Duck typing approach:
  assert(type(shape.area)=="function","needs area()")
  return shape:area()
end

print(area({area=function() return 16 end}))  -- 16

Pergunta sobre Polimorfismo

Como o polimorfismo funciona em Lua?

Recapitulação: Sobrescrita e Polimorfismo

Sobrescreva os métodos da classe-pai redefinindo-os na classe-filha. Lua resolve as chamadas de baixo para cima pela cadeia __index, obtendo naturalmente um despacho polimórfico em tempo de execução.

Perguntas Frequentes

A aula “Sobrescrita e polimorfismo” é grátis?

Sim — o texto completo de “Sobrescrita e polimorfismo” é 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 “Sobrescrita e polimorfismo”?

Sobrescreva métodos da classe-pai e obtenha despacho polimórfico em tempo de execução. 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 4 de 4.

Quanto tempo leva a aula “Sobrescrita e polimorfismo”?

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. Herança única com encadeamento de __index
  2. Chamando métodos da classe-pai com super
  3. Padrões de mixins
  4. Sobrescrita e polimorfismo
← Voltar para Lua Academy