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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
//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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
//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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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:pagar_emprestimo(); cliente10:pagar_emprestimo(); 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:
|
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>.