quinta-feira, 29 de janeiro de 2009
Série objective-C 06 -Separando os arquivos de implementação e interface
Editoria:
Curso Objective-c
Estamos de volta, dando prosseguimento a série de artigos sobre objective-c, hoje iremos aprender como dividir as nossas classes em arquivos de implementação e de interfaces para facilitar a organização e reutilização.
Sempre recebo e-mail de leitores perguntando sobre tópicos avançados, mas queria deixar claro que estes artigos tem objetivo de abordar o básico do objective-c e assim que terminarmos esta introdução iremos falar sobre programação em ambiente gráfico e para dispositivos como o iPhone e o iPod, tenho certeza que esta introdução pode ajudar para quem nunca teve contato com estas tecnologias, esta com certeza é a minha intenção. Espero os comentários e o feedback dos amigos leitores. Leia o restante do artigo.
Artigos anteriores:
Série objective-c 1 - Primeira aplicação via console texto
Série objective-c 2 - Primeira aplicação compilada via X-Code
Série objective-c 3 - Exercícios de fixação
Série objective-c 4 - Orientação a objetos
Série objective-c-5 – Estrutura lógica de um programa objective-c
No artigo anterior estudamos a estrutura lógica de um programa construído com objective-c explicamos sobre:
@interface section
@implementation section
program section
No exemplo mostrado, o programa era um único arquivo .m que continha todas as seções, a interface, implementation e o programa principal. A titulo de exemplo, isto é válido para conhecer a estrutura da programação em objective-c, mas com o passar do tempo seus programas irão aumentar de tamanho e a divisão dos programas é vital para melhor organização e reutilização do código.
Hoje iremos aprender a separar as nossas classes em arquivos separados, dividindo a interface da implementação, para uma melhor organização e posterior reutilização do código.
EXEMPLO PROPOSTO
Temos o seguinte problema, queremos fazer a conversão entre moedas, a titulo de exemplo, vamos pensar em DOLAR para REAL, o usuário tem uma quantia em dolares e quer converter para reais, e nossa classe fará isto. Vou colocar um pequeno diagrama para facilitar o entendimento e a programação da classe.
Nossa classe será chamada ConverteMoeda.
Resumo do diagrama acima:
a) Uma classe chamada ConverteMoeda conforme a instrução:
Class ConverteMoeda
b) Nossa classe tem dois atributos definidos
quantidade: Atributo do tipo float ( para receber parte decimal de um número ), responsavel por armazenar a quantidade da moeda que iremos converter.
cambio: Atributo float, receberá o valor do cambio para fazer a conversão da moeda.
A classe terá 5 métodos
OBS: Foram implementados métodos acessores get e set para retornar e atualizar os valores dos atributos, em objective-c temos um recurso mais simples para acessar os atributos, mas veremos este conceito nos próximos artigos.
getQuantidade: Retorna um float com o valor do atributo quantidade.
GetCambio: Retorna um float com o valor do atributo cambio
setQuantidade: Permite atualizar o valor do atributo quantidade
setCambio: Permite atualizar o valor do atributo cambio
printConversao: Calcula e retorna o valor da conversao entre as moedas.
Já entendemos o problema e fizemos um diagrama básico da classe, chegou a hora de iniciar a codificação.
O detalhe é que a partir de agora as nossas classes serão separadas em arquivos para facilitar a organização e a reutilização, ta legal, eu sei que já falei isto antes. :)
Os arquivos tem extensões, geralmente para identificar o conteúdo e a sua utilidade, arquivos swf são para Flash, mp3 músicas e por ai vai. Em objective-c por convenção os arquivo com extensão .m irão conter códigos e os .h serão os arquivos de cabeçalho, ou seja a parte da interface declaração da classe, atributos e assinatura dos métodos irão ficar em arquivos .h e a implementação ou a codificação propriamente dita em arquivos .m
No nosso exemplo criamos o diagrama para construir a classe ConverteMoeda, de acordo a metodologia explicada, teremos 2 arquivos:
ConverteMoeda.h
ConverteMoeda.m
Atenção:
A numeração das linhas foram incluidas apenas para facilitar a explicação devem ser incluidas para testar os programas.
Arquivo ConverteMoeda.h
01 // --------------------------- Inicio da codificação -----------------------------------
02 // Interface Class: ConverteMoeda
03 // Arquivo: ConverteMoeda.h
04 // Programador: Pierre Freire
05 // E-mail: blog@pierrefreire.com.br
06 // Versao: 0.01
07 //
08 #import < objc/Object.h >
09 @interface ConverteMoeda:Object
10 {
11 float quantidade;
12 float cambio;
13 }
14 -(float) getQuantidade;
15 -(float) getCambio;
16 -(void) setQuantidade: (float) quantidadeMoeda;
17 -(void) setCambio: (float) cambioMoeda;
18 -(float) printConversao;
19 @end
//--------------------------- Fim da codificação -----------------------------------
Comentários sobre ConverteMoeda.h
Linha 01-07: São apenas um comentário no programa
Linha 08: Usamos a diretiva #import para incluir a classe Object
Linha 09: Inicio da declaração da classe, informamos o seu nome ConverteMoeda e usamos
a herança para que ele herde caracteristicas da SuperClasse Object, métodos como
init e free que iremos usar são implementados nesta Classe.
Linha 10-13: Definimos os atributos de nossa classe.
Linha 14: Método que vai retornar um float com o valor do atributo quantidade
Linha 15: Método que vai retornar um float com o valor do atributo cambio
Linha 16: Método que recebe um parametro chamado quantidadeMoeda e atualiza atributo
quantidade.
Linha 17: Método que recebe um parametro chamado câmbioMoeda e atualiza atributo cambio
Linha 18: Este método vai calcular o valor do câmbio e retornar um float com o resultado.
Linha 19: Finaliza o bloco de interface da classe.
Definimos o arquivo com a interface de nossa classe, vamos agora criar o arquivo para implementar as funcionalidades que definimos.
ConverteMoeda.m
01 // --------------------------- Inicio da codificação -----------------------------------
02 // Implementation: Class ConverteMoeda
03 // Arquivo: ConverteMoeda.m
04 // Programador: Pierre Freire
05 // E-mail: blog@pierrefreire.com.br
06 // Versao: 0.01
07
08 #import "converteMoeda.h"
09
10 @implementation ConverteMoeda
11
12 -(float) getQuantidade
13 {
14 return quantidade;
15 }
16
17 -(float) getCambio
18
19 {
20 return cambio;
21 }
22
23 -(void) setQuantidade: (float) quantidadeMoeda
24 {
25 quantidade=quantidadeMoeda;
26 }
27
28 -(void) setCambio: (float) cambioMoeda
29 {
30 cambio=cambioMoeda;
31 }
32
33 -(float) printConversao;
34
35 {
36 return cambio*quantidade;
37 }
38
39 @end
40 //--------------------------- Fim da codificação -----------------------------------
Linha 01-07: São apenas um comentário no programa
Linha 08: Usamos a diretiva #import para incluir a interface que definimos ConverteMoeda.h
Linha 10: Iniciamos o bloco de implementação da classe
Linha 12-15: Implementamos o método getQuantidade onde retornamos um float com o valor
do atributo quantidade.
Linha 17-21 Implementamos o método getCambio onde retornamos um float com o cambio
Linha 23-26 Implementamos o método setQuantidade onde recebemos o parâmetro
quantidadeMoeda e atualizamos o valor do atributo quantidade
Linha 28-31 Implementamos o método setCambio onde recebemos o parâmentro cambioMoeda
e atualizamos o valor do atributo cambio.
Linha 33-41 Implementamos o método printConversao onde multiplicamos o cambioXquantidade
e retornamos o valor da conversão.
Linha 39 Fechamos o bloco de implementação com @end.
Finalizamos a nossa classe, dividimos em 2 arquivos, o converteMoeda.h e o converteMoeda.m e agora podemos utilizar esta classe onde for necessário.
Vamos criar agora um arquivo chamado CalculaMoeda.m para testar a nossa classe.
CalculaMoeda.m
01 // Programa Conversao de moedas
02 // Arquivo: CalculaMoeda.m
03 // E-mail: blog@pierrefreire.com.br
04 // Versao: 0.01
05
06 #import < stdio.h >
07 #import "converteMoeda.h"
08 int main (int argc, char *argv[])
09 {
10 // Cria um objeto do tipo ConverteMoeda
11 // Aloca um espaco para o objeto dolar e o inicializa
12 ConverteMoeda *dolar=[[ConverteMoeda alloc] init];
13
14 // Usando metodo setQuantidade do objeto dolar
15 // Estamos informando a quantidade de dolares que queremos converter
16 [dolar setQuantidade: 12];
17
18 // Usando metodo setCotacao do objeto dolar
19 // Vamos informar o valor da cotacao, vamos imaginar em REAIS
20 [dolar setCambio: 2.30];
21 // Usando o metodo printSaldo
22 // Imprimindo o resultado
23 printf("Quantidade de dolares............%10.2f\n",[dolar getQuantidade]);
24 printf("Taxa de cambio em Reais.......%10.2f\n",[dolar getCambio]);
25 printf("Valor da conversao............... %10.2f\n",[dolar printConversao]);
26
27 // Liberando o objeto da memoria - Metodo free
28 [dolar free];
29 return 0;
30 }
Linha 01-05: São simples comentários do programa
Linha 06: Importando a biblioteca stdio.h, para usarmos a função prinft no programa.
Linha 07: Importando a nossa classe ConverteMoeda para que possamos usa-la no programa.
Linha 08: Declara o inicio da função main responsável por iniciar a execução do programa.
Linha 09: Delimitador do bloco de inicio do programa
Linha 12: Nesta linha declaramos o ponteiro *dolar sendo do tipo ConverteConta, e alocamos e inicializamos o objeto. Em relação aos artigos anteriores executamos estes passos em uma única linha. Para relembrar esta linha poderia ser escrita da seguinte forma também.
IMPLEMENTAÇAO 01:
ConverteMoeda *dolar;
dolar = [ConverteMoeda alloc];
dolar = [dolar init];
IMPLEMENTAÇAO 02:
ConverteMoeda *dolar=[[ConverteMoeda alloc] init];
A implementação 02 passará a ser usada neste e nos próximos artigos.
Linha 16: Nesta linha usamos o método setQuantidade para indicar a quantidade de doláres que
queremos calcular.
Linha 20: Usamos o método setCambio com o valor da cotação da moeda.
Linha 23: Usamos a função printf para imprimir na tela a quantidade de dolares, usando o método getQuantidade.
Linha 24: Usamos a função printf para imprimir na tela o valor do cambio usando o getCambio
Linha 25: Imprime o valor da conversão usando o método printConversão.
OBS: o parametro %10.2f, indica que o número vai ter 10 digitos no máximo e 2 casas decimais o f vem de float e o \n indica uma quebra de linha.
Linha 28: Usamos o método free para liberar o objeto, vale a pena comentar que este método podemos usar porque nossa classe ConverteMoeda herda de Object que implementa esta método.
Linha 29: Esta linha retorna o controle ao SO indica que tudo terminou bem.
Para compilar:
gcc CalculaMoeda.m ConverteMoeda.m -o moeda -lobjc
gcc: Invoka o compilador gcc
CalculaMoeda.m e converteMoeda: São os arquivo com os fontes
-o moeda: Indica o nome do arquivo de saida, o executavel, escolha fica a criterio
-lobjc: Indica que deve ser usado as bibliotecas objective-c
Para executar:
./moeda
Resultado:
Quantidade de dolares............ 12.00
Taxa de cambio em Reais....... 2.30
Valor da conversao............... 27.60
Agora com este exemplo simples, aprendemos como dividir as classes em arquivos separados de interface e implementação e usa-la em outro programa. Existem muitas coisas a saber sobre classes, fizemos apenas uma pequena introdução, futuramente iremos tratar deste assunto de forma mais profunda. Nos próximos artigos falaremos sobre os tipos, estruturas de controle e de decisões para que possamos finalizar a parte básica da linguagem.
Mais informações:
http://www.rodrigomerino.com.br ( Blog onde escrevo artigos também ).
Assinar:
Postar comentários (Atom)
Postagens
Muito Interessante, Pierre
ResponderExcluirO artigo parece estar muito interessante e bem detalhado, porém ainda não tive tempo de segui-lo passo a passo
Va acha que eu devo atualizar meu sdk antes de continuar os estudos?
Abraço
Thiago,
ResponderExcluirTentei fazer a atualização 1,75 gb é muita coisa para baixar. Cheguei a baixar 1.o gb porem caiu. Qu raiva eu fiquei.
Mas para estudar pelo por enquanto a atualização não é tão vital.
se conseguir baixar, diga-me quanto fica pra me mandar uma copia via correios hehehe
ResponderExcluirAbraço
Pierre,
ResponderExcluirParabéns pelo site e pelos exemplos, parabéns por estar ajudando. Estou aprendendo muito com seus artigos a programar em objective-c. Só uma sugestão, seria legal se colocasse algums imagens mostrando como fica no pc, como um passo a passo mesmo. No Macbook apertando COMMAND + SHIFT + 4 você pode selecionar a área e gerar uma imagem .png.
@Mauricio Junior: Obrigado Mauricio, vou tentar ilustrar os proximos, realmente fica bem melhor.
ResponderExcluirSugestões são sempre bem vindas.
Abraços.
Estou muito contente com estes artigos e estou ansioso pelos próximos..
ResponderExcluirPosso dizer que aprendi muito aqui, pq aqui ta explicado de uma forma suave e inteligente!
Pierre, gosto muito desses seus artigos e caso vc pudesse apresentar locais que tenham conteudos interessantes de obj-c agradeço
Abraço
@Gustavo, obrigado pelo feedback, em breve estarei postando algumas novidades em relação ao objective-c.
ResponderExcluirO site da Apple é a minha principal referência.
Abraços.