Terça-feira, 18 de Novembro de 2008

Série objective-C 05 -Estrutura lógica de um programa objective-c

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

Amigos do blog,

Obrigado pelos feedbacks e vários e-mails que tenho recebido, sempre que precisarem podem entrar em contato.
No último artigo nós vimos os primeiros passos em orientação a objetos e escrevemos o primeiro programa, hoje irei fazer uma revisão rápida sobre a estrutura lógica de um programa em objective-c, é importante que leiam o artigo Série objective-c 4 - Orientação a objetos para terem um melhor aproveitamento deste artigo.
Hoje iremos ver mais detalhes da estrutura lógica de um programa objective-c.

Existem 3 seções fundamentais em um programa:

1. @interface section
2. @implementation section
3. program  section

A @interface section é onde você descreve a classe, uma espécie de contrato, onde você define o que será implementado na sua classe, informa o nome da classe, seus atributos, métodos.
A @implementation section é onde codificamos os métodos que foram definidos na interface.
3. programa section é o inicio do programa em si, onde definimos a função main e o que ela vai executar.

Cada seção tem suas tarefas bem definidas em objective-c, inclusive é recomendavel que elas sejam divididas em arquivos diferentes ou seja um arquivo para @interface section, outro para @implementation e mais um para o programa principal. No nosso exemplo inicial usamos apenas um, mas no decorrer deste curso iremos aprender a usa-los separados.

1. @interface section

Quando você deseja criar uma classe, primeiro você define a sua interface, o nome da classe, de qual classe ela vai herdar funcionalidades ( não obrigatório ), quais os atributos e métodos que esta classe irá ter, esta é a parte de interface que devemos escrever em um programa objective-c.

@interface ClassName: ParentClassName
{
      atributos;
}
métodos;
@end

// Exemplo prático

@interface Funcionario: Object
{
       int  cpf
       int anoNascimento;
}
-(void) setCpf: (int) nCpf;
-(void) setAnoNascimento: (int) nAno;
-(void) printFicha;
@end

Definimos uma classe chamada Funcionario que vai herdar caracteristicas de uma super classe chamada Object, esta classe vai ter os atributos  cpf e anoNascimento e 3 métodos de instância setCpf, setAnoNascimento e printFicha.

Esta é a seção interface de um programa objective-c, leia este artigo e estude o exemplo do artigo anterior.


2. @implementation section

A seção de implementação é onde você vai escrever o código dos métodos que foram definidos na interface, caso você defina um método na interface, mas não escreva sua implementação na hora da compilação, será dado um aviso que o método definido na interface não foi implementado, mas o programa vai ser compilado, caso por algum razão da vida, queira definir um método e não implementa-lo totalmente, você pode definir a assinatura do método e a parte da codificação entre {} deixar em branco.

@implementation ClassName;
   métodos;
@end

Exemplo prático

@implementation Funcionario;
 -(void) setCpf: (int) nCpf
 {
      cpf = nCpf;
 }

-(void) setAnoNascimento: (int) nAno
{
    ano=nAno;
}

-(void) printFicha
{
       printf("Ficha do funcionario\n");
      printf("CPF: %i",cpf);
      printf("Ano Nascimento:%i",ano);
}

@end

@implementation Funcionario;
Iniciamos a implementação dos métodos definidos na classe Funcionário.

-(void) setCpf: (int) nCpf
Esta é a assinatura do método setCpf definido na interface funcionário.
-   O sinal de - indica que é um método de instância, caso fosse estático seria +
(void) se refere ao retorno do método, neste caso void indica que ele nao retorna nada
setCpf:  Nome do método
(int) nCpf informa que na hora da chamada, este método recebe um parametro inteiro
{} O código para implementação do método deve estar entre chaves

// A implementação dos outros métodos...

@end Finaliza o bloco de implementação.



3. Program Section

Esta é a parte onde se inicia o seu programa a partir da função main.

int main (argc,char argv[])
{
        Funcionario *pierre;        
       pierre=[Funcionario alloc];
       pierre=[pierre init];
       [pierre setCpf 12345674831];
       [pierre setAnoNascimento 1969];
       [pierre printFicha]; 
       [pierre free];     
       return 0;
}

Este linha indica que pierre é um objeto do tipo funcionário, ele é usado para guardar valores da classe Funcionário, o * indica que ele é um ponteiro, iremos ver sobre ponteiros mais adiante.
Funcionario *pierre;

Nesta linha nós estamos allocando um espaço da memória para o objeto pierre, ou seja foi disponibilizada uma área da memória para este objeto, não podemos ainda acessar seus atributos e métodos porque eles ainda não foram inicializados.
pierre=[Funcionario alloc];

Depois de alocar espaço na memória, inicializamos o objeto ou seja tornamos acessiveis as suas propriedades e métodos.
pierre=[pierre init]

Agora com o objeto instanciado, estamos usando os métodos que implementamos, o método setCpf e passando o parametro 12345674831. 
[pierre setCpf 12345674831]


Usando método setAnoNascimento e passando o parametro 1969. Em Java poderia ser algo do tipo pierre.setAnoNascimento(1969)
[pierre setAnoNascimento 1969]

Abaixo usamos o método printFicha como podem ver ele não requer parametros.
[pierre printFicha]

Abaixo usamos o método free, este método a exemplo do alloc e do init, não foi implementado por nós, mas sim herdado da classe Object, analisem a parte de interface, para comprovarem este fato, já deu para perceber como a herança é um conceito importante em OOP. Este método libera a memória usada pelo objeto, geralmente usamos quando não precisamos mais do objeto no nosso programa.
[pierre free]

É o retorno da função main.
return 0;

Chegamos ao fim de mais um artigo da série objective-c, espero que tenha ficado claro estes conceitos iniciais da estrutura lógica de um programa em objective-c. Agora é continuar os estudos e praticando sempre.

Abraços,

Pierre


Segunda-feira, 17 de Novembro de 2008

Série objective-C 04 - Orientação a Objetos


Artigos da Série

Série Objective-C 01 - Primeira aplicação via Console Texto
Série Objective-C 02 - Primeira aplicação compilada via XCode

Estou de volta ao blog e hoje iremos falar sobre orientação a objetos no objective-c. Iremos trabalhar com um exemplo simples e ilustrar os conceitos de classe, objetos métodos e atributos.
Aos que não tem  familiaridade com este paradigma de programação, recomendo ler materiais sobre o assunto, pois o domínio da programação orientada a objetos é vital no desenvolvimento de aplicações em objective-c.
Vejam o link abaixo:

Até agora vimos exemplos extremamente simples e usando apenas a função main, nada diferente dos programas feitos em C ansi. 
Vamos estudar alguns aspectos mais específicos do objective-c, em especial a orientação a objetos. Vamos escrever um pequeno programa que armazena e exibe o saldo de uma conta corrente. Como se trata de um exemplo,  nesta versão, não iremos contemplar, saques, depósitos, apenas o número da conta e saldo.
Abaixo temos um diagrama de classe bem simples, do que iremos implementar, recomendo darem uma olhada em UML em especial diagrama de classes para quem tiver dúvidas.










Diagrama da Classe Conta:

No diagrama acima, estamos definindo a classe Conta:

Nome da nossa classe
Class Conta 

São definidos 2 atributos, saldo e conta, private indica que eles serão acessiveis apenas dentro da classe, isto mostra um exemplo de um dos conceitos de OOP o encapsulamento, logo a seguir definimos os tipos destes atributos int e float.
private int: conta
private float: saldo

Métodos da classe
Os métodos trazem funcionalidades as classes,  nesta diagrama de classe definimos 3 métodos: 
setConta, setSaldo e printSaldo. Eles tem escopo público(public), diferente dos nossos atributos, eles podem ser acessados de fora da nossa classe,  o parametro void indica que eles não terão retorno algum. Os métodos setConta e setSaldo serão chamados mas terão um parametro obrigatório na hora da chamada respectivamente int e float.

public void setConta(int)
public void setSaldo(float)
public void printSaldo()

Codificando em objective-c

Agora que entendemos o nosso diagrama de classe, temos os atributos e os métodos definidos vamos escrever o nosso primeiro programa em objective-c com programação orientada a objetos.

Use o seu editor ou IDE favorito e vamos iniciar os trabalhos.
É importante saber que um programa em objective-c tem 4 partes bem definidas:

01. Diretrizes para o pré-processador
02. Definição da interface das classes
03. Implementação dos métodos definidos na interface
04. A função main e o ínicio do programa em si.

Listagem do programa em azul:


// Programa exemplo orientação a objetos
// Programador: Pierre Freire
// E-mail: blog@pierrefreire.com.br
// Versao: 0.01

//------------ Definindo as diretrizes -------------
#import <>
#import <>

//------------- Definição da interface das classes --------------

@interface Conta:Object
{
  int conta;
  float saldo;
}
-(void)  setConta: (int) numberConta;
-(void)  setSaldo: (float) valorOperacao;
-(void)  printSaldo;
@end

//----------------- Implementação dos métodos definidos na classe --------------------

@implementation Conta
-(void) setConta: (int) numberConta
{
   conta=numberConta;
}

-(void) setSaldo: (float) valorOperacao
{
   saldo=valorOperacao;
}

-(void) printSaldo;
{
  printf("Extrato bancario \n\n");
  printf("-----------------------\n");
  printf("Conta:%i\n",conta);
  printf("Saldo:%f\n",saldo);
}
@end

//------------- Programa principal ---------------

int main (int argc, char *argv[])
{
   // Cria um objeto do tipo Conta
   Conta *itau;

   // Aloca um espaco para o objeto itau e inicializa
   itau = [Conta alloc];
   itau = [itau init];

   // Usando metodo setConta do objeto itau
   [itau setConta: 12];

   // Usando metodo setSaldo do objeto itau
   [itau setSaldo: 200.00];

   // Usando o metodo printSaldo
   [itau printSaldo];

   // Liberando o objeto da memoria - Metodo free
   [itau free];
   return 0;
}



Entendendo o código

01 - Definindo as diretrizes do pré-processador
//------------ Definindo as diretrizes -------------
#import <>
#import <>

Como comentamos anteriormente este parte do código, definimos as diretrizes do pré-processador, neste caso, incluimos a biblioteca stdio.h porque estamos usando a função printf e a Object.h porque estamos usando a classe Object.


02 - Definindo a interface da classe

//------------- Definição da interface das classes --------------

@interface Conta:Object
{
  int conta;
  float saldo;
}
-(void)  setConta: (int) numberConta;
-(void)  setSaldo: (float) valorOperacao;
-(void)  printSaldo;
@end


A definição da interface da classe é uma espécie de contrato, onde você define o nome da sua classe, se ela herda característica de outra classe os atributos que a compoem e os métodos que ela irá ter.  Ou seja definimos apenas a estrutura da classe.

Definimos a interface, o nome da classe será Conta e ela é subclasse de Object ou seja ele herda todos os métodos e atributos desta classe. Definimos os atributos conta e saldo sendo tipo int ( inteiro) e float respectivamente.

 @interface Conta:Object
{
  int conta;
  float saldo;
}


Definimos os 3 métodos da classe o sinal de - indica que será um método de instância ou seja ele só pode ser acessado depois de instanciada o objeto da classe, mas adiante veremos mais detalhes sobre isto. setConta e setSaldo necessitam de um parametro do tipo int e a variavel usada para este parametro é definida logo adiante numberConta e valorOperação respectivamente. O @end fecha o bloco.
-(void)  setConta: (int) numberConta;
-(void)  setSaldo: (float) valorOperacao;
-(void)  printSaldo;
@end

03 - Implementação dos métodos definidos na classe


Inicio do bloco de implementação da classe Conta
@implementation Conta

Implementação do método setConta, o método não retorna nada (void) na sua chamada ele recebe um inteiro(int) que será armazenado na variavel numberConta no corpo do método definido pelos "{}" ele armazena no atributo conta o número passado por parâmetro.
-(void) setConta: (int) numberConta
{
   conta=numberConta;
}

Implementação do método setSaldo, o método não retorna nada (void) na sua chamada ele recebe um float(float) que será armazenado na variavel valorOperacao no corpo do método definido pelos "{}" ele armazena no atributo saldo o número passado por parâmetro.

-(void) setSaldo: (float) valorOperacao
{
   saldo=valorOperacao;
}

Este método nada retorna (void) não recebe parametros e simplesmente imprime as informações armazenadas por setConta e setSaldo.

-(void) printSaldo;
{
  printf("Extrato bancario \n\n");
  printf("-----------------------\n");
  printf("Conta:%i\n",conta);
  printf("Saldo:%f\n",saldo);
}
@end


4 - Programa principal
Nesta parte do código é de fato onde se inicia a execução do nosso programa, vamos ver passo a passo o que acontece.

Função main, é o inicio do programa, ela retorna um inteiro ao seu final e alguns parametros podem ser passados via linha de comando, mais adiante veremos como isto funciona.
int main (int argc, char *argv[])
{
   
Nesta linha criamos uma variavel chamada itau, que guardará valores da classe Conta, ou seja poderemos acessar os métodos e atributos desta classe atraves deste objeto, o * informa que itau é também um ponteiro.
   Conta *itau;

Antes de usarmos o objeto é necessário alocar espaço na memória para ele.
   itau = [Conta alloc];

Após alocar espaço inicializamos as variaveis que fazem parte do objeto, no nosso exemplo os atributos conta e saldo.
   itau = [itau init];

Tudo pronto, começamos a usar o nosso objeto, acessamos o método setConta definido na classe e passamos o parâmetro 12 para ele. Algumas linguagens se usam o ponto, por exemplo em Java esta chamada poderia ser itau.setconta(12), abaixo a chamada deste método em objective-c.
   [itau setConta: 12];

Aqui estamos executando o método setSaldo e passando o valor 200.00, como ele aceita um float podemos passar a parte decimal.
   [itau setSaldo: 200.00];

Agora que preenchemos os atributos do objeto conta e saldo, usamos o método print para imprimir o resultado na console.
   [itau printSaldo];

 Já usamos o objeto para atribuir os valores e imprimir, agora usamos o método free para liberar a memória, este método não foi criado por você, como a nossa classe Conta herda Object ela pode usar este método que pertence a Object, este é o conceito de herança, não tivemos o trabalho de implementar este método, simplesmente herdamos ele de outra classe.
   [itau free];

Estamos finalizando a função main e na declaração dela ela exige que se retorne um inteiro, estamos retornando o valor zero, que na verdade é um código para informar ao Sistema operacional que o programa terminou com sucesso.
   return 0;
}

Resultado do programa.

Extrato bancario 
-----------------------
Conta:12
Saldo:200.000000


Bem, ficamos por aqui, estude o exemplo, crie um programa qualquer parecido e poste suas dúvidas nos comentários ou me mande um e-mail.
Na próxima aula iremos fazer alguns exercícios e incrementaremos o nosso programa de conta, adicionando novos métodos. E estude orientação a objetos.

Abraço a todos.

Terça-feira, 4 de Novembro de 2008

De volta ao Blog

Amigos,

Estou envolvido em um projeto de trabalho e fiquei alguns dias sem atualizar o blog, mas já estou trabalhando no novo artigo da série objective-c. Em breve estarei publicando.

Abraço a todos. 


Terça-feira, 21 de Outubro de 2008

Série objective-C 03 - Exercícios de fixação

Artigos da série


Nos dois primeiros artigos, criamos uma aplicação básica e compilamos na linha de comando editando o texto com o VIM e usando a IDE XCode via interface gráfica. Em relação a edição ficará a criterio de cada um, seja usando o Vim, XCode ou outro editor que se sentir mais confortavel.

* Usuários Linux e Windows
Outro detalhe que gostaria de falar é em relação aos usuários de windows e Linux, estes poderão acompanhar os artigos e compilar os programas com as respectivas ferramentas de cada sistema. No Linux poderão usar o GCC e o Mingw no Windows, nestes artigos iremos nos focar no objective-c que é linguagem base para que possamos mais tarde usar o Cocoa e desenvolver softwares para Mac, Iphone e Ipod.


Quem puder ajudar, pode colocar nos comentários ou faz um roteiro da instalação do objetive-c no Linux e no windows.

A fim de fixar o aprendizado irei colocar alguns programas pequenos para analisarmos. 



# Para compilar no terminal

macbook-de-pierre:curso-objectiveC pierre$ gcc program2.m -o program2 -lobjc

# Executar o programa
macbook-de-pierre:curso-objectiveC pierre$ ./program2 
Primeira linha
Segunda linha

Entendendo o programa

Esta linha permite usar as funções da biblioteca stdio.h, no caso a função printf
  #import  "<stdio.h>"

As linhas precedidas pelo simbolo / são comentários e portanto ignoradas pelo compilador
// Desenvolvido por Pierre Freire
// E-mail: blog@pierrefreire.com.br
// Versao: 0.01
// Nome: program2.m

Esta linha demarca o inicio da função main que coloca o programa em funcionamento

O int no inicio é um contrato onde a função se compromete a retornar um valor inteiro. 
ela é chamada com dois parametros:  o primeiro é o número de argumentos que serão passados
via linha de comando e o outro quais são estes parametros ( veremos mais adiante )
int main (int argc,const char *argv[])

As chaves delimitam o corpo do program.
{}

A função printf imprime a string entre aspas, o \n é um caractere de controle que indica uma quebra de linha, ou seja no exemplo a string "Segunda linha, sera impressa na outra linha, por causa do \n.
printf("Primeira linha\n");
printf("Segunda linha\n");

Finaliza o programa retornando o inteiro prometido no inicio da funcao main o 0 é um código que o programa retorna geralmente para informar que ele terminou com sucesso.
return 0



# Compilar o programa
macbook-de-pierre:curso-objectiveC pierre$ gcc program3.m -o program3 -lobjc

# Resultado do programa
macbook-de-pierre:curso-objectiveC pierre$ ./program3 
26

#Novidades
A novidade nesta linha é que a função printf agora tem dois argumentos ( parametros ), o primeiro dentro da string temos o caractere de controle %i que indica que o proximo argumento a ser impresso é um inteiro e o \n que todos já conhecem né, para ele saltar para a próxima linha.
printf("%i\n",22+4);




# Compilar o programa
macbook-de-pierre:curso-objectiveC pierre$ gcc program4.m -o program4 -lobjc

# Resultado do programa
macbook-de-pierre:curso-objectiveC pierre$ ./program4 
Media calculada --> 8.500000

# Novidades
Neste programa a novidade que usamos variaveis pela primeira vez, criamos 3 variaveis do tipo float, este tipo permite que a variavel guarde valores que tenham casas decimais como 8.5 por exemplo. eles foram declaradas e inicializadas com um valor fixo cada uma.
A media foi armazenada baseada no valor de nota1 e nota2.
A Linha printf agora mudou um pouco no primeiro argumento imprimos a string:
 Media calculada ---> e informamos que o segundo parametro a ser impresso seria do tipo float com o caractere de controlo %f e o\n para saltar para próxima linha.

Existem mais detalhes a serem vistos em relação a variaveis e outros aspectos, o principal objetivo deste exercicio é fixar a aprendizagem com a edição dos códigos e uso do compilador.

No próximo artigo falaremos um pouco sobre orientacao a objeto e daremos os primeiros exemplos de uso no objective-c.

Observações: Os programas em objective-c devem ter a extensao .m


Enquanto isso, estudem e continuem mandando e-mail para trocarmos informações.

Abraços.




Série Objective-C 02 - Primeira aplicação compilada via XCode

Artigos da série


Objetivos
Compilar programa objective-c com o XCode

No artigo anterior, criamos e compilamos a nossa primeira aplicação em objective-c via console em modo texto, hoje iremos conhecer o básico para compilar a mesma aplicação usando o XCode a IDE oficial para desenvolvimento no mundo Apple.

01 - Abrindo o Macintosh HD
Na área de desktop ( mesa ) você clica no ícone do Macintosh HD conforme figura abaixo:


02 - Acessando a pasta Developer 
O Xcode esta instalado na pasta developer, como pode ver abaixo, clique para ela expandir


03 - Localizando e executando o XCode
Dentro de Developer na pasta Application você encontrará o Xcode, clique para ele iniciar, veja na figura abaixo:


04 - Tela inicial do XCode
A tela inicial do XCode será aberta, tem algumas opções criar aplicação, feche esta janela.
PS: close this window


05 - Barra do Docs, o XCode é o símbolo do martelo, veja abaixo:


06 - Executando o XCode a partir do Docs, clique no ícone do martelo veja a figura:


07 - Criando um projeto no Xcode
Vamos criar o nosso primeiro projeto, no menu superior perto da maçã, escolha File / New Project, como mostra a figura abaixo:


08 - Escolhendo um template ( modelo ) de projeto.
Nesta tela temos vários templates, para desenvolvimento de aplicações para Iphone e Mac OS X, no nosso caso vamos escolher Mac OS X / Command Line Utility / Foundation Tool.
Estamos informando que estamos criando uma aplicação de console e que irá usar as classes existentes na Foundation Tool. ( iremos ver mais detallhes em outros artigos ). Veja a figura abaixo:


09 - Escolhendo um nome para o projeto
Agora nesta tela, podemos escolher em que pasta e qual será o nome do projeto, no exemplo ele ficará na pasta curso-objectiveC e terá o nome de firstApp. Conforme a figura.


10 - Tela de gerenciamento do projeto no Xcode
 O Xcode exibe a tela de gerenciamento de projeto, selecione o arquivo firstApp.m, conforme mostra a figura irá notar que ele já traz um código pronto para se trabalhar com a foundation. Mas no nosso caso queremos executar o programa que fizemos no artigo anterior. Apague o código escrito. 



11 - Digitando o nosso programa
Agora selecione o firstApp.m e digite o código da aula anterior. ( azul )

#import

int main (int argc, const char *argv[])
{
   printf ("Primeiro programa em objective-c \n");
   return 0;
}



12 - Configurando o XCode para executar o programa em modo console ( texto )
Clique em Preferences, conforme a tela abaixo:


13 - Configurando preferências para executar em modo console.
Depois de clicar nas preferências selecione DEbugging e na opção On Start: selecione Show Console.
Agora use Apply e OK


14 - Executando o programa
Nesta tela, agora clique no ícone do martelo em Build and Go


15 - Salvando o projeto
Cada vez que executar um programa ele pergunta se deseja salvar as alterações feitas para
que estas sejam compiladas. Responda Save All.


16 - O resultado do programa na console.



Bem, já fizemos o nosso primeiro programa e escrevemos e compilando usando o modo console e outra versão com o XCode.
É importante conhecer os dois caminhos, o XCode será de muito valia, quando estivermos usando a Cocoa e o ambiente gráfico.
Fiquem a vontade para me mandar e-mail e postarem nos comentários. em breve teremos o artigo número 3.

Abraços a todos.

Segunda-feira, 20 de Outubro de 2008

Série Objective-c 01 - Conceitos iniciais e primeira aplicação compilada via console de texto

Objetivos:
- Conhecer objective-c
- Compilar primeiro programa via console

Pré-requisitos: Mac OS instalado e conhecimento de alguma linguagem de programação.
Ferramentas de desenvolvimento instaladas ( Existem outras maneiras para instalar as ferramentas, tem um artigo aqui no blog falando sobre uma das maneiras ) 

Observações: Esta série de artigos tem o intuito de ensinar um pouco do que tenho aprendido em desenvolvimento para o mundo Apple, vale a pena dizer que sou novo em desenvolvimento nestas tecnologias e escrever estes posts no blog é uma maneira de compartilhar informações com as pessoas interessadas nestas tecnologias e eventualmente aprender também, então a regra é esta, eu ajudo vocês e consequentemente vocês me ajudam e assim poderemos construir uma base de conhecimento para outros que virão. Então não esperem a excelência, apenas entendam que é um esforço que estou fazendo e gostaria de dividir com outras pessoas.
 

Neste primeiro artigo vamos fazer o nosso primeiro programa para funcionar na plataforma Mac, será uma aplicação em modo texto e codificada em objective-c.
O objective-c é a linguagem oficial para desenvolvimento de aplicativos no mundo Apple, é uma linguagem híbrida com características da linguagem c e da smalltalk, do C, ela traz a velocidade, simplicidade de codificação e do Smalltalk entre tantos caracteristicas traz a orientação a objetos como um diferencial ( Caso não conheça os conceitos de OOP ) recomendo que estude em paralelo. Nestes primeiros artigos iremos estudar bastante o objective-c, o framework Cocoa, será uma segunda série, assim que tivermos os conhecimentos básicos do objective-c. Vale lembrar que com o Cocoa poderemos fazer aplicativos gráficos e aplicações para rodarem nos Mac, Iphone e Ipod ( Chegaremos lá ).
Existem duas maneiras para programarmos em objective-c podemos codificar nossa aplicação via console ( direto na linha de comando do Mac Os ) ou usando o XCode a IDE que é muito usada no desenvolvimento de aplicações o mundo Apple.

01 -Executando o terminal e acessando a console do sistema

No Windows as vezes usamos o executar e digitamos o comando cmd para termos acesso ao DOS ( Lembram dele ? ) os que vieram do Linux já estão acostumados com o termo console e já sabem do que estamos falando. Para ter acesso a console é necessário fazer o seguinte:

Acessa o menu no finder escolha a opção utilitários na janela que será aberta selecione terminal e a linha de comando irá aparecer. As figuras abaixo mostram a sequência a ser seguida. A linha de comandos é similar ao Linux, mas o Mac Os é da família que segue o padrãoPosix.






02 - Escrevendo a primeira aplicação objective-c

Vamos aproveitar e criar uma pasta para as nossas aplicações. Para isto use o seguinte comando. No meu caso, aparece o nome do meu computador e a minha home ( pasta do usuário atual ).

# Criamos a pasta curso-objectiveC
macbook-de-pierre:~ pierre$ mkdir  curso-objectiveC

# Entramos na pasta criado
macbook-de-pierre:~ pierre$ cd  curso-objectiveC

# Chamamos o editor de textos para escrever o nosso primeiro programa ele se chamará start
macbook-de-pierre:curso-objectiveC pierre$vim start.m

Na linha de comando acabamos de chamar o editor de textos chamado Vim, muito conhecido dos usuários de Linux. 


Você agora esta no VI, aperte a letra I, ele vai entrar em modo de inserção e digite o programa a seguir: ( As linhas azuis )



#import

int main (int argc, const char *argv[])
{
   printf ("Primeiro programa em objective-c \n");
   return 0;
}
Abaixo a tela do programa codificado no editor VIM



Agora para salvarmos o nosso programa, no VIM teclamos seguido de : irá aparecer um espaço e você digita wq, ele vai sair gravando. Conforme a tela abaixo.



Com isto voltamos a linha de comandos do sistema.

# Compilando o programa, para isto execute o comando abaixo
macbook-de-pierre:curso-objectiveC pierre$gcc start.m -o start -lobjc

Com esta operação será gerado um arquivo com o nome start, que é o nosso programa compilado.

# Executando e logo abaixo o resultado.
macbook-de-pierre:curso-objectiveC pierre$./start
Primeiro programa em objective-c

As telas a seguir mostram a sequência do que falamos.





03 - Comentando a primeira aplicação objective-c

Para os programadores em C, o código mostrado tem grande semelhança a linguagem C ansi, lembram que falei que o objective-c herda alguma coisas do C? Este primeiro exemplo mostrou isto, nos próximos apesar de sintaticamente parecido irão notar que o desenvolvimento é diferente porque o objective-c segue o paradigma de orientação a objetos e o C ansi uma linguagem procedural.

01   #import
02 int main (int argc, const char *argv[])
03 {
04   printf ("Primeiro programa em objective-c \n");
05   return 0;
06 }

Linha 01 
A directiva #import , carrega a biblioteca stdio que permite o uso de diversas funções do objective-c no exemplo sua inclusão foi necessário porque usamos a função printf logo abaixo que faz parte desta biblioteca. Para os programadores C Ansi, eles normalmente usam #include ao invés de #import.

Linha 02
Inicio da função main, ela é responsavel pelo ponto de partida de um sistema em C, o parametro int indica que ela deve retornar um inteiro ao final de sua execução, logo depois temos dois argumentos, o primeiro retorna o número de parametros passados via linha de comando e o segundo quais são eles, por ora é isto, vamos ver mais detalhes ao longo da Série.

Linha 03
Estamos executando a função printf, que faz parte da biblioteca stdio.h importada logo acima, ela imprime mensagens em um dispositivo de saida no nosso caso a console. Ela tem várias formas de ser chamada, neste primeiro exemplo, usamos a função com um parametro uma string.
E finalizando, a função return, terminamos com return 0, o zero é para informar que o programa terminou e tudo correu bem. Retornamos um inteiro, porque na linha 2, foi feito um contrato que a função iria retornar um inteiro.

Os parenteses delimitam o bloco de código.

04 - Comentando os parâmetros para compilação
gcc start.m -o start -lobjc

gcc: Indica que quero usar o compilador gcc
start.m: é o arquivo com o programa que digitamos
-o : vem de output, indica qual nome o arquivo executavel vai ter
start: escolhemos start para o nome do nosso arquivo, mas poderia ser outro
-lobjc: O -l vem de library (biblioteca) -lobjc indica que usaremos as bibliotecas
              do objective-c para compilar o nosso programa.

Observação: Os usuários de Linux e windows poderão acompanhar esta série e
testarem os programas usando o gcc no linux e o mingw no windows.
Quando usarmos a Cocoa mais adiante, pelo que estudei até o momento ela
não tem port ainda para estes SO. 


Bem amigos, este exemplo foi muito simples, uma introdução simples dos conceitos iniciais de objective-c.

No próximo artigo da série, vamos compilar e executar o mesmo programa, porém usando o Xcode a IDE oficial do MacOS.

Abraços,

E me mandem um e-mail ou postem comentários.


Série artigos - Aprendendo objective-c

Leitores do blog, 

Como vocês sabem, estou me dedicando ao estudo de tecnologias para desenvolvimento para plataforma Apple, focando Macs, Iphone e Ipod. Nos últimos artigos falamos:


Já conhecemos as tecnologias e sabemos como preparar o ambiente de desenvolvimento, nesta série de artigos  iremos conhecer os conceitos básicos para criação de programas. A tecnologia escolhida foi a linguagem objective-c e o framework Cocoa por serem as ferramentas onde são construidas a maioria das aplicações para Mac, Iphone e Ipod.
Como estou estudando diariamente, postar as informações que vou adquirindo é uma forma de solidificar os conceitos e também aprender com os colegas interessados nestas tecnologias.
Abraço a todos.