Orientação a objetos simples e avançado

Orientação em objetos é um paradigma difícil de se introduzir no mundo da programação. Atualmente temos diversas linguagens que suportam esse mecanismo como o C++, Python, Ruby etc. Outras que forçam unicamente esse tipo de programação como Java, por exemplo.

Prisma como uma modificação do código original Lua, não tem a orientação a objetos nativamente, mas tem os mecanismos necessários para se chegar a ela. Para tanto foi implementada uma biblioteca com a classe primordial para criar as outras e com um método principal para derivar os objetos.

Pense em poo (programação orientada a objetos) como uma organização diferente. As funções (como imprima(), leia() tente() convstring() etc) e dados ( como: peso, altura, comprimento, gastos, saldo, preço, cliente_a , cliente_b etc) não ficam avulsas como na programação estruturada (blocos de funções e estruturas de dados).
Mas ficam empacotados em uma única variável chamada classe, da qual podemos declarar novas variáveis que automaticamente herdam as funções e dados da classe pai.

Bom chega de blá blá blá e vamos programar:

Um exemplo bem simples primeiro:

//exemplo classe simples:
//importando a lib "classe"
inclua'classe';

//note que a funcao que cria classe é inicial maiuscula "Classe()";

//criando uma classe com dados em valores padrões:
pessoa = Classe{nome = 'nao definido' , idade = 'nao definido' } ; //nova classe chamada 'pessoa'
funcao pessoa.mostre_dados( este )
     poe'---------------------------------------------------------------';
     imprima(este.nome);
     imprima(este.idade);
fim

 //quando usamos dois pontos no método
//não precisamos passar explicitamente o parâmetro este
//fica subentendido:
funcao pessoa:denome( nome )
     este.nome = nome;
fim

funcao pessoa:deidade( idade )
    este.idade = idade;
fim

maria = pessoa:novo{  };
maria:mostre_dados();
maria:denome('Maria'); //agora damos um nome
maria:mostre_dados(); //mas idade está nulo ainda

//criando um novo objeto pessoa com dados 
// já passados
joao = pessoa:novo{ nome = 'Joao' , idade = 28 };
joao:mostre_dados();

//exemplo classe simples:

//importando a lib "classe"

inclua'classe';

//note que a funcao que cria classe é inicial maiuscula "Classe()";

//criando uma classe com dados em valores padrões:

pessoa = Classe{nome = 'nao definido' , idade = 'nao definido' } ; //nova classe chamada 'pessoa'

funcao pessoa.mostre_dados( este )

poe'---------------------------------------------------------------';

imprima(este.nome);

imprima(este.idade);

fim

//quando usamos dois pontos no método

//não precisamos passar explicitamente o parâmetro este

//fica subentendido:

funcao pessoa:denome( nome )

este.nome = nome;

fim

funcao pessoa:deidade( idade )

este.idade = idade;

fim

maria = pessoa:novo{ };

maria:mostre_dados();

maria:denome('Maria'); //agora damos um nome

maria:mostre_dados(); //mas idade está nulo ainda

//criando um novo objeto pessoa com dados

// já passados

joao = pessoa:novo{ nome = 'Joao' , idade = 28 };

joao:mostre_dados();

Veja a saída (Ubuntu 14.04):

Um mais avançado:

//Para criarmos classes e depois objetos em Prisma precisamos incluir a biblioteca 'classe':
inclua'classe'; 

//criando uma nova classe chamada conta_bancaria:
conta = Classe{ 
nome = '' , //dado nome do usuario da conta
saldo = 0, //definindo um saldo padrão = zero

despositar = funcao( este , n )  
     este.saldo = este.saldo + n; //somando o novo deposito ao saldo atual;
fim ;
sacar = funcao( este , n  )
   este.saldo = este.saldo - n ; //subtraindo do saldo atual
fim ;
poupanca = 0 ;  //definindo valor da poupanca

transf_para_poupanca = funcao(este , n )
       imprima('\n' , sis.data() , '\nDeposito da conta corrente para poupanca, valor: ' , n , '\n' );
     este.saldo = este.saldo - n; //tirando da conta corrente
    este.poupanca = este.poupanca + n; //colocando na poupanca
fim ;

transf_para_conta = funcao ( este , n )
   imprima('\n' , sis.data() , '\nDeposito da poupanca para conta, valor: ' , n , '\n' );
    este.poupanca = este.poupanca - n;
    este.saldo = este.saldo + n;
fim  ; //nunca se esqueça de separar por ponto e vírgula ou vírgula

mostre_nome = funcao(este) imprima('\nNome :' , este.nome, '\n') fim;
mostre_saldo = funcao( este )  imprima( 'Saldo conta corrente :' , este.saldo, '\n' ) fim ;
mostre_poupanca = funcao( este ) imprima('Poupanca :' , este.poupanca, '\n' ) fim 

}


//feito a classe conta podemos fazer objetos a partir dela como o metodo novo

conta_padaria = conta:novo({nome = 'Conta padaria'}); 
//se preferir pode descartar os parênteses quando passar uma tabela.
conta_padaria:mostre_nome();
conta_padaria:mostre_saldo();
conta_padaria:mostre_poupanca();

//voce pode passar uma tabela redefinindo os dados:
conta_pessoal = conta:novo{nome = 'Paulo-conta' , saldo = 250.00 };
conta_pessoal:mostre_nome(); //imprime o nome
conta_pessoal:mostre_saldo(); //imprime o saldo conta corrente
conta_pessoal:mostre_poupanca(); //imprime saldo poupanca
conta_pessoal:despositar( 1000.00 ); //deposita
conta_pessoal:mostre_saldo(); //imprime saldo
conta_pessoal:transf_para_poupanca( 250.00 ); //transfere para poupanca
conta_pessoal:mostre_saldo();  //imprime saldo
conta_pessoal:mostre_poupanca(); //imprime poupanca

//Para criarmos classes e depois objetos em Prisma precisamos incluir a biblioteca 'classe':

inclua'classe';

//criando uma nova classe chamada conta_bancaria:

conta = Classe{

nome = '' , //dado nome do usuario da conta

saldo = 0, //definindo um saldo padrão = zero

despositar = funcao( este , n )

este.saldo = este.saldo + n; //somando o novo deposito ao saldo atual;

fim ;

sacar = funcao( este , n )

este.saldo = este.saldo - n ; //subtraindo do saldo atual

fim ;

poupanca = 0 ; //definindo valor da poupanca

transf_para_poupanca = funcao(este , n )

imprima('\n' , sis.data() , '\nDeposito da conta corrente para poupanca, valor: ' , n , '\n' );

este.saldo = este.saldo - n; //tirando da conta corrente

este.poupanca = este.poupanca + n; //colocando na poupanca

fim ;

transf_para_conta = funcao ( este , n )

imprima('\n' , sis.data() , '\nDeposito da poupanca para conta, valor: ' , n , '\n' );

este.poupanca = este.poupanca - n;

este.saldo = este.saldo + n;

fim ; //nunca se esqueça de separar por ponto e vírgula ou vírgula

mostre_nome = funcao(este) imprima('\nNome :' , este.nome, '\n') fim;

mostre_saldo = funcao( este ) imprima( 'Saldo conta corrente :' , este.saldo, '\n' ) fim ;

mostre_poupanca = funcao( este ) imprima('Poupanca :' , este.poupanca, '\n' ) fim

}

//feito a classe conta podemos fazer objetos a partir dela como o metodo novo

conta_padaria = conta:novo({nome = 'Conta padaria'});

//se preferir pode descartar os parênteses quando passar uma tabela.

conta_padaria:mostre_nome();

conta_padaria:mostre_saldo();

conta_padaria:mostre_poupanca();

//voce pode passar uma tabela redefinindo os dados:

conta_pessoal = conta:novo{nome = 'Paulo-conta' , saldo = 250.00 };

conta_pessoal:mostre_nome(); //imprime o nome

conta_pessoal:mostre_saldo(); //imprime o saldo conta corrente

conta_pessoal:mostre_poupanca(); //imprime saldo poupanca

conta_pessoal:despositar( 1000.00 ); //deposita

conta_pessoal:mostre_saldo(); //imprime saldo

conta_pessoal:transf_para_poupanca( 250.00 ); //transfere para poupanca

conta_pessoal:mostre_saldo(); //imprime saldo

conta_pessoal:mostre_poupanca(); //imprime poupanca

Note que:

*este* é uma palavra reservada que simboliza a tabela do próprio objeto passado como parâmetro ‘este’;
São usados dois pontos *:* para acessar um método de um objeto: conta_pessoal:mostre_poupanca();

HERANÇA

Muitas vezes queremos construir uma nova classe, mas não do zero, seria bom pegar os dados e os métodos emprestados de uma classe já existente, isso se chama herança, pois a nova classe recebe como base uma antiga e herda seus atributos:

Analise o seguinte código, uma modificação do anterior:

//Para criarmos classes e depois objetos em Prisma precisamos incluir a biblioteca 'classe':
inclua'classe'; 

//criando uma nova classe chamada conta_bancaria:
conta = Classe{ 
nome = '' , //dado nome do usuario da conta
saldo = 0, //definindo um saldo padrão = zero

despositar = funcao( este , n )  
     este.saldo = este.saldo + n; //somando o novo deposito ao saldo atual;
fim ;
sacar = funcao( este , n  )
   este.saldo = este.saldo - n ; //subtraindo do saldo atual
fim ;
poupanca = 0 ;  //definindo valor da poupanca

transf_para_poupanca = funcao(este , n )
       imprima('\n' , sis.data() , '\nDeposito da conta corrente para poupanca, valor: ' , n , '\n' );
     este.saldo = este.saldo - n; //tirando da conta corrente
    este.poupanca = este.poupanca + n; //colocando na poupanca
fim ;

transf_para_conta = funcao ( este , n )
   imprima('\n' , sis.data() , '\nDeposito da poupanca para conta, valor: ' , n , '\n' );
    este.poupanca = este.poupanca - n;
    este.saldo = este.saldo + n;
fim  ; //nunca se esqueça de separar por ponto e vírgula ou vírgula

mostre_nome = funcao(este) imprima('\nNome :' , este.nome, '\n') fim;
mostre_saldo = funcao( este )  imprima( 'Saldo conta corrente :' , este.saldo, '\n' ) fim ;
mostre_poupanca = funcao( este ) imprima('Poupanca :' , este.poupanca, '\n' ) fim 

}


//feito a classe conta podemos fazer objetos a partir dela como o metodo novo

conta_padaria = conta:novo({nome = 'Conta padaria'}); 
//se preferir pode descartar os parênteses quando passar uma tabela.
conta_padaria:mostre_nome();
conta_padaria:mostre_saldo();
conta_padaria:mostre_poupanca();

//voce pode passar uma tabela redefinindo os dados:
conta_pessoal = conta:novo{nome = 'Paulo-conta' , saldo = 250.00 };
conta_pessoal:mostre_nome(); //imprime o nome
conta_pessoal:mostre_saldo(); //imprime o saldo conta corrente
conta_pessoal:mostre_poupanca(); //imprime saldo poupanca
conta_pessoal:despositar( 1000.00 ); //deposita
conta_pessoal:mostre_saldo(); //imprime saldo
conta_pessoal:transf_para_poupanca( 250.00 ); //transfere para poupanca
conta_pessoal:mostre_saldo();  //imprime saldo
conta_pessoal:mostre_poupanca(); //imprime poupanca


//podemos criar uma outra classe a partir da classe conta, heranca
conta2 = Classe( conta ); //ao passar a classe conta como parametro
// a nova classe conta2 tera automaticamente os dados e metodos
//da classe conta; isso se chama heranca

//adicionando dados e metodos extras que nao existem em conta
//veja que a adicao foi posterior, sem usar chaves, isso não importa:
conta2.numero = 0; 
conta2.emprestimo_total = 0;
conta2.emprestimo_restante_pagar = 0;
conta2.emprestimo_parcela = 0;
conta2.emprestimo_num_parcelas = 0;

conta2.mostre_extrato = funcao(este)
   imprima'-------------------------------------------------------------';
   imprima'                    extrato geral                              ';
   imprima( 'Titular da conta:' , este.nome , '\n');
   imprima('saldo conta:', este.saldo );
   imprima( 'saldo poupanca:' , este.poupanca );
   imprima( '\nEmprestimo:' );
   imprima( 'Valor total a pagar:' , este.emprestimo_total );
   imprima("Total restante a pagar:" , este.emprestimo_restante_pagar);
   imprima('Valor de cada parcela:' , este.emprestimo_parcela );
   imprima( 'Parcelas restantes:' , este.emprestimo_num_parcelas );
fim

conta2.emprestar = funcao( este , valor , parcelas )

      este.emprestimo_total = valor + valor * 0.2; //20 por cento do total
      este.emprestimo_restante_pagar = este.emprestimo_total;
      este.emprestimo_parcela = este.emprestimo_total / parcelas; 
      este.emprestimo_num_parcelas = parcelas;

fim

conta2.pagar_emprestimo = funcao ( este )
       este:sacar( este.emprestimo_parcela );//esta funcao foi herdada de conta.
       este.emprestimo_restante_pagar  =  //nao tem problema ir para outra linha
       este.emprestimo_restante_pagar - este.emprestimo_parcela;
       
       este.emprestimo_num_parcelas = este.emprestimo_num_parcelas - 1;
       //diminuiu uma parcela;       
fim

//criando um novo objeto com alguns dados:
cliente10 = conta2:novo( {nome = 'Maria' , numero = 10 , saldo = 12000 } )
poe('------------------------------------------------------');
cliente10:mostre_nome();
cliente10:mostre_saldo();
cliente10:emprestar ( 1000.00 , 12 );
cliente10:mostre_extrato();
poe'\n------------------------------------------------------------------';
poe'             paga 1 parcela            ';

cliente10:transf_para_poupanca( 2000.00);
cliente10:pagar_emprestimo();
cliente10:mostre_extrato();
cliente10:pagar_emprestimo();
cliente10:pagar_emprestimo();
cliente10:pagar_emprestimo();
cliente10:pagar_emprestimo();

cliente10:mostre_extrato();

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

//Para criarmos classes e depois objetos em Prisma precisamos incluir a biblioteca 'classe':

inclua'classe';

//criando uma nova classe chamada conta_bancaria:

conta = Classe{

nome = '' , //dado nome do usuario da conta

saldo = 0, //definindo um saldo padrão = zero

despositar = funcao( este , n )

este.saldo = este.saldo + n; //somando o novo deposito ao saldo atual;

fim ;

sacar = funcao( este , n )

este.saldo = este.saldo - n ; //subtraindo do saldo atual

fim ;

poupanca = 0 ; //definindo valor da poupanca

transf_para_poupanca = funcao(este , n )

imprima('\n' , sis.data() , '\nDeposito da conta corrente para poupanca, valor: ' , n , '\n' );

este.saldo = este.saldo - n; //tirando da conta corrente

este.poupanca = este.poupanca + n; //colocando na poupanca

fim ;

transf_para_conta = funcao ( este , n )

imprima('\n' , sis.data() , '\nDeposito da poupanca para conta, valor: ' , n , '\n' );

este.poupanca = este.poupanca - n;

este.saldo = este.saldo + n;

fim ; //nunca se esqueça de separar por ponto e vírgula ou vírgula

mostre_nome = funcao(este) imprima('\nNome :' , este.nome, '\n') fim;

mostre_saldo = funcao( este ) imprima( 'Saldo conta corrente :' , este.saldo, '\n' ) fim ;

mostre_poupanca = funcao( este ) imprima('Poupanca :' , este.poupanca, '\n' ) fim

}

//feito a classe conta podemos fazer objetos a partir dela como o metodo novo

conta_padaria = conta:novo({nome = 'Conta padaria'});

//se preferir pode descartar os parênteses quando passar uma tabela.

conta_padaria:mostre_nome();

conta_padaria:mostre_saldo();

conta_padaria:mostre_poupanca();

//voce pode passar uma tabela redefinindo os dados:

conta_pessoal = conta:novo{nome = 'Paulo-conta' , saldo = 250.00 };

conta_pessoal:mostre_nome(); //imprime o nome

conta_pessoal:mostre_saldo(); //imprime o saldo conta corrente

conta_pessoal:mostre_poupanca(); //imprime saldo poupanca

conta_pessoal:despositar( 1000.00 ); //deposita

conta_pessoal:mostre_saldo(); //imprime saldo

conta_pessoal:transf_para_poupanca( 250.00 ); //transfere para poupanca

conta_pessoal:mostre_saldo(); //imprime saldo

conta_pessoal:mostre_poupanca(); //imprime poupanca

//podemos criar uma outra classe a partir da classe conta, heranca

conta2 = Classe( conta ); //ao passar a classe conta como parametro

// a nova classe conta2 tera automaticamente os dados e metodos

//da classe conta; isso se chama heranca

//adicionando dados e metodos extras que nao existem em conta

//veja que a adicao foi posterior, sem usar chaves, isso não importa:

conta2.numero = 0;

conta2.emprestimo_total = 0;

conta2.emprestimo_restante_pagar = 0;

conta2.emprestimo_parcela = 0;

conta2.emprestimo_num_parcelas = 0;

conta2.mostre_extrato = funcao(este)

imprima'-------------------------------------------------------------';

imprima' extrato geral ';

imprima( 'Titular da conta:' , este.nome , '\n');

imprima('saldo conta:', este.saldo );

imprima( 'saldo poupanca:' , este.poupanca );

imprima( '\nEmprestimo:' );

imprima( 'Valor total a pagar:' , este.emprestimo_total );

imprima("Total restante a pagar:" , este.emprestimo_restante_pagar);

imprima('Valor de cada parcela:' , este.emprestimo_parcela );

imprima( 'Parcelas restantes:' , este.emprestimo_num_parcelas );

fim

conta2.emprestar = funcao( este , valor , parcelas )

este.emprestimo_total = valor + valor * 0.2; //20 por cento do total

este.emprestimo_restante_pagar = este.emprestimo_total;

este.emprestimo_parcela = este.emprestimo_total / parcelas;

este.emprestimo_num_parcelas = parcelas;

fim

conta2.pagar_emprestimo = funcao ( este )

este:sacar( este.emprestimo_parcela );//esta funcao foi herdada de conta.

este.emprestimo_restante_pagar = //nao tem problema ir para outra linha

este.emprestimo_restante_pagar - este.emprestimo_parcela;

este.emprestimo_num_parcelas = este.emprestimo_num_parcelas - 1;

//diminuiu uma parcela;

fim

//criando um novo objeto com alguns dados:

cliente10 = conta2:novo( {nome = 'Maria' , numero = 10 , saldo = 12000 } )

poe('------------------------------------------------------');

cliente10:mostre_nome();

cliente10:mostre_saldo();

cliente10:emprestar ( 1000.00 , 12 );

cliente10:mostre_extrato();

poe'\n------------------------------------------------------------------';

poe' paga 1 parcela ';

cliente10:transf_para_poupanca( 2000.00);

cliente10:pagar_emprestimo();

cliente10:mostre_extrato();

cliente10:pagar_emprestimo();

cliente10:mostre_extrato();

Veja a saída, em Ubuntu 14.04:

HERANÇA MÚLTIPLA

Herdar dados e métodos de várias classes ao mesmo tempo. Não há muita diferença do exemplo anterior, basta na hora de criar a nova classe passar quantas classes antigas precisar como parâmetro, veja:

nova_classe = Classe(  {meus_novos_atributos...} , classe_antigaA , classeAntigaB , ... );

1	nova_classe = Classe( {meus_novos_atributos...} , classe_antigaA , classeAntigaB , ... );

Note que para mais de um parâmetro não podemos omitir os parênteses da função Classe;

Bom, pessoal, é isso aí, orientação a objetos não é muito fácil, mas merece dedicação, pois quando se programa assim fica bem organizado.

O exemplo acima é sem interface gráfica, mas basta adaptar e usar a criatividade com ig que o trabalho será legal.

É possível fazer classes de funções gráficas facilmente.

Valeu, obrigado por ler e usar Prisma, qualquer dúvida deixe um comentário aqui ou vá ao fórum clicando <aqui>.

Prisma

linguagem de programação em português

Orientação a objetos simples e avançado

Deixe um comentário Cancelar resposta