Leia os artigos anteriores:

Série objective-c 05 – Estrutura lógica de um programa objective-c
Série objective-c 04 – Orientação a objetos
Série objective-c-0 3 – Exercícios de fixação

*

Sempre
recebo e-mail de leitores perguntando sobre tópicos avançados, mas
queria deixar claro que estes artigos têm 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.
Vamos ao artigo.

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 título 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 título
de exemplo, vamos pensar em DOLAR para REAL. O usuário tem uma quantia
em dólares 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 ),
responsável por armazenar a quantidade da moeda que iremos converter.

cambio: atributo float, receberá o valor do câmbio para fazer a conversão da moeda.

A classe terá 5 métodos:

Observação:: 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 conversão 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. Tá legal, eu
sei que já falei isto antes. 🙂

Os
arquivos têm extensões, geralmente para identificar o conteúdo e a sua
utilidade: arquivos swf são para Flash, mp3 para músicas e por aí vai. Em
objective-c, por convenção, os arquivos 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 dois arquivos:

ConverteMoeda.h

ConverteMoeda.m

Atenção: A numeração das linhas foram incluídas apenas para facilitar a explicação, devem ser incluídas 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: Início da declaração da classe. Informamos o seu nome ConverteMoeda e usamos a herança para que ele herde características 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 parâmetro chamado quantidadeMoeda e atualiza atributo quantidade.

Linha 17: Método que recebe um parâmetro 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.

Arquivo 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 -----------------------------------

Comentários de ConverteMoeda.m

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âmetro 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   }

Comentários

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 usá-la no programa.

Linha 08: Declara o início da função main responsável por iniciar a execução do programa.

Linha 09: Delimitador do bloco de início 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.

Implentação 01

   ConverteMoeda *dolar;
   dolar = [ConverteMoeda alloc];
   dolar = [dolar init];

Implentação 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 dólares, 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 parâmetro %10.2f, indica que o número vai ter 10 dígitos 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 este 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 saída, o executável, escolha fica a critério.

-lobjc: Indica que devem ser usadas as bibliotecas objective-c.

Para executar:

./moeda

Resultado:

Quantidade de dólares………… 12.00

Taxa de câmbio em Reais……. 2.30

Valor da conversão …………….. 27.60

Agora
com este exemplo simples, aprendemos como dividir as classes em
arquivos separados de interface e implementação e usá-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.