Os métodos são funções associadas aos nossos objetos para executar suas ações. Em Lua, associamos uma função anônima à uma table para simulação.

Métodos públicos em Lua são funções anônimas associadas a uma table como mostrado na sintaxe abaixo:

Sintaxe

minha_classe = {}
minha_classe.nome_metodo = function(parametros)
--corpo
end

Um método privado, por sua vez, é uma função local definida/declarada dentro de uma table. Esse tipo de método não pode ser acessado fora da classe.

Sintaxe

nome_classe.construtor = function()
    local function nome_metodo(parametros)
      --corpo
    end
end

Exemplo 1: método público e privado

--classe
local MinhaClasse = {} --table

--construtor público
MinhaClasse.construtor = function()
    local classe = {} 

    local function MetodoPrivado(valor)
        print("privado param:",valor);
    end
   
    function classe.MetodoPublico(valor)
        print("publico param:",valor)
        print("invocando método privado via público")
        MetodoPrivado(valor) 
    end
    return classe
end

--instância
local objeto = MinhaClasse.construtor()
objeto.MetodoPublico("string")

Saída

publico param:	string
invocando método privado via público
privado param:	string

Como estamos simulando uma classe, precisamos criar um construtor padrão para instanciar nossos objetos:

Sintaxe

nome_classe.construtor = function()
 --corpo
end

Exemplo 2

MinhaClasse.construtor = function()
    local classe = {}     
    return classe
end

Saída

-

Para instanciar nossos objetos de forma parametrizada, podemos definir um construtor com parâmetros como mostrado abaixo:

Sintaxe: construtor

variavel_classe.construtor = function(lista_parametros)
 --corpo
end

Exemplo 3

local MinhaClasse = {}

MinhaClasse.construtor = function(a)
    local classe = {} 
    classe.MinhaPropriedade = a --public
    return classe
end 

local objeto = MinhaClasse.construtor(888)
print("prop:",objeto.MinhaPropriedade);

Saída

prop:	888

Para a simulação de encapsulamento em Lua, vamos utilizar o conceito dos métodos Get/Set usados na linguagem Java, por exemplo, onde definimos métodos para acessar uma propriedade encapsulada como private(local).

Sintaxe

local nome_atributo = valor_inicial -- private

Sintaxe

function variavel_local.Get_nome_propriedade() --get
    return nome_propriedade
end
    
function variavel_local.Set_nome_propriedade(parametro) --set
    MinhaPropriedadePrivada = parametro
end

Exemplo 4

local MinhaClasse = {}

--construtor público
MinhaClasse.construtor = function()
    local classe = {} 
    
    classe.MinhaPropriedade = 999 --public
    local MinhaPropriedadePrivada = "valor inicial" -- private
    
    function classe.GetPropriedadePrivada() --get
        return MinhaPropriedadePrivada
    end
    
    function classe.SetPropriedadePrivada(valor) --get
        MinhaPropriedadePrivada = valor
    end
    
    return classe
end

local objeto = MinhaClasse.construtor()
print("prop publica:",objeto.MinhaPropriedade);
print("get prop privada:", objeto.GetPropriedadePrivada());
print("set prop privada:", objeto.SetPropriedadePrivada("novo valor"))
print(objeto.GetPropriedadePrivada());

Saída

prop publica:	999
get prop privada:	valor inicial
set prop privada:
novo valor

Métodos estáticos em algumas linguagens POO, são métodos acessados sem a necessidade de uma instância. Em Lua, a simulação é feita adicionando um método como no exemplo abaixo:

Exemplo 5

local MinhaClasse = {} --table
MinhaClasse.MetodoEstatico = function (valor)
print(valor)
end

MinhaClasse.MetodoEstatico(999)

Saída

999