Os programas em Objective-C possuem quatro partes bem definidas. A primeira define diretrizes para o pré-processador, a segunda define as classes e métodos, a terceira a implementar os métodos e a quarta é o programa em si. Mais tarde mostraremos como cada parte pode ficar armazenada em um arquivo separado, facilitando a organização do programa em si.

Para facilitar, podemos iniciar lendo o programa a seguir que define nossa primeira classe, o Cao. Esse dócil animal late, logo vamos implementar uma classe Cao que possui um método chamado miau que serve apenas para escrever Au! na tela. Veja o código:

meuCao.m
// aqui começam as diretrizes do pre-processador
#import <stdio.h>
#import <objc object.h="">
// aqui comeca a definicao das interfaces
@interface Cao: Object
-(void) latir;
@end
 
// aqui comecam as implementacoes dos metodos
@implementation Cao
-(void) Latir
{
    printf("Au!\n");
}
@end
 
// aqui comeca o programa
int main( int argc, const char *argv[] ) 
{
        Cao *meuCao;
        meuCao = [Cao alloc];
        meuCao = [meuCao init];
        [meuCao latir];
        [meuCao free];
        return 0;
}
 
</objc></stdio.h>

Todas as linhas que iniciam por // são linhas de comentários. Estas são ignoradas, logo é permitido escrever qualquer coisa após as duas barras. Comentários são utilizados para documentar um programa, facilitando sua compreensão.

Outra forma de inserir comentários em programas Objective-C é utilizar os caracteres /* no início do comentário e */ no final; desta forma pode-se criar blocos de comentário com muitas linhas, sem que seja necessário escrever // a cada linha nova.

As linhas iniciadas por # são diretrizes de pré-processamento. No programa acima utilizamos #import <...>, que diz para o compilador localizar, processar e importar informações dos arquivos stdio.h e objc/Object.h, ambos arquivos do sistema. Estes arquivos contém informações sobre a rotina printf e a classe Object, que foram utilizadas no nosso programa.

A segunda parte do arquivo consiste na definição das Classes e de suas interfaces. Quando nós definimos uma nova classe é necessário dizer ao compilador algumas coisas. A primeira delas é falar de onde a classe vem, ou seja quem é a sua superclasse. Utilizamos para isso a seção @interface, cujo formato geral é:

@interface NovaClasse: SuperClasse
{
        Declaração_de_variáveis;
}
Declaração_de_métodos;
 
@end

No nosso programa definimos a classe Cao, que por enquanto não possuem variáveis e apenas um método, o latir. Esse é um método da instância da classe Cao, pois sua declaração é iniciada com o símbolo -. Poderíamos também criar um método da própria classe Cao utilizando o símbolo + para, por exemplo, contar o número de cães que foram criados no programa.

Após o sinal - temos a declaração entre parênteses do que o método irá retornar; no caso, void, indica que nada será retornado. Finalmente temos o nome do método. Mais adiante forneceremos o formato geral de declaração de métodos.

A terceira parte do arquivo é a implementação dos métodos da classe. Ela define os métodos, ou seja, contém seus códigos declarados na parte @interface. O formato é:

@interface NovaClasse 
Definição_de_métodos;
@end

A definição de um método nada mais é do que sua declaração sem o caractere ; acompanhada por seu código, que é colocado entre chaves { e }. No nosso programa, o método latir tem o código definido por uma instrução da biblioteca stdio.h chamada printf, que serve para mostrar caracteres na tela.

A quarta e última parte do arquivo, é o programa em si. Esta parte contem a rotina denominada main que indica precisamente onde o programa deve iniciar sua execução. Ela inicia com a palavra int, especificando que main deve retornar um valor inteiro ao sistema quando terminar sua execução. As palavras que aparecem entre parêntesis () servem para lidar com argumentos passados pela linha de comando.

A primeira linha da rotina main define uma variável chamada meuCao, dizendo que meuCao é um objeto que guardará valores da classe Cao. O asterísco diz que meuCao é um ponteiro para um Cao.

Na segunda linha alocamos espaço na memória para o meuCao, e na terceira inicializamos as variáveis que podem estar presentes dentro do meuCao. Observe que na segunda linha passamos uma mensagem para a classe Cao, enquanto que na terceira a mensagem vai para a instância meuCao. Os métodos alloc e init não foram escritos por você, entretanto podemos utilizá-los pois foram definidos para a classe Object, que é a superclasse de Cao.

Na quarta linha passamos uma mensagem para o objeto meuCao, dizendo para ele miar, ou seja, executar o método latir que implementamos.

Na quinta linha passamos uma mensagem para meuCao dizendo que ele não será mais necessário, e que podemos liberar a memória que foi reservada à ele.

Na sexta linha especificamos o valor que o programa deve retornar ao sistema; no caso 0, indicando que tudo ocorreu bem.

Vamos finalmente compilar e executar o nosso programa. Para gerar o executável deve-se utilizar um compilador, no caso o gcc, e como visto anteriormente sua chamada (desta vez já com os nomes dos arquivos corretos) é:

gcc meuCao.m -o meuCao -l objc

Executando o arquivo meuCao deve-se obter a seguinte saída:

Au!

Confira também