quinta-feira, 29 de janeiro de 2009

Série objective-C 06 -Separando os arquivos de implementação e interface

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 ).


7 comentários:

  1. Muito Interessante, Pierre

    O 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

    ResponderExcluir
  2. Thiago,

    Tentei 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.

    ResponderExcluir
  3. se conseguir baixar, diga-me quanto fica pra me mandar uma copia via correios hehehe
    Abraço

    ResponderExcluir
  4. Pierre,
    Parabé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.

    ResponderExcluir
  5. @Mauricio Junior: Obrigado Mauricio, vou tentar ilustrar os proximos, realmente fica bem melhor.
    Sugestões são sempre bem vindas.

    Abraços.

    ResponderExcluir
  6. Estou muito contente com estes artigos e estou ansioso pelos próximos..
    Posso 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

    ResponderExcluir
  7. @Gustavo, obrigado pelo feedback, em breve estarei postando algumas novidades em relação ao objective-c.
    O site da Apple é a minha principal referência.

    Abraços.

    ResponderExcluir