Manipulando Tab Bar

SOURCE
TesteBarraAppDelegate.h

//
//  TesteBarraAppDelegate.h
//  TesteBarra
//
//  Created by Luís Cláudio on 26/07/09.
//  Copyright __MyCompanyName__ 2009. All rights reserved.
//

#import <UIKit/UIKit.h>

@interface TesteBarraAppDelegate : NSObject <UIApplicationDelegate> {
UIWindow *window;
IBOutlet UITabBarController *meuTabBarController;
}

@property (nonatomic, retain) IBOutlet UIWindow *window;
@property (nonatomic, retain) IBOutlet UITabBarController *meuTabBarController;

@end

TesteBarraAppDelegate.m

//
//  TesteBarraAppDelegate.m
//  TesteBarra
//
//  Created by Luís Cláudio on 26/07/09.
//  Copyright __MyCompanyName__ 2009. All rights reserved.
//

#import “TesteBarraAppDelegate.h”

@implementation TesteBarraAppDelegate

@synthesize window;
@synthesize  meuTabBarController;

- (void)applicationDidFinishLaunching:(UIApplication *)application {

// Override point for customization after application launch
[window addSubview:[meuTabBarController view]];
[window makeKeyAndVisible];
}

- (void)dealloc {
[meuTabBarController release];
[window release];
[super dealloc];
}

@end

Olá pessoal… Estamos de volta.
E agora aprendendo a fazer nosso primeiro menu usando a tableview. Embaixo do vídeo segue o código para quem não quiser digitar. Um abraço…

CRIANDO UM MENU COM TABLEVIEW

Código rootviewcontroller.h

//
//  RootViewController.h
//  Menu
//
//  Created by Luís Cláudio on 28/06/09.
//  Copyright __MyCompanyName__ 2009. All rights reserved.
//

#import <UIKit/UIKit.h>

@interface RootViewController : UITableViewController {
NSArray *menu;
}

@end

Código rootviewcontroller.m

//
//  RootViewController.m
//  Menu
//
//  Created by Luís Cláudio on 28/06/09.
//  Copyright __MyCompanyName__ 2009. All rights reserved.
//

#import “RootViewController.h”
#import “MenuAppDelegate.h”
#import “Tela1ViewController.h”

@implementation RootViewController

- (void)viewDidLoad {
self.title= @”Meu primeiro Menu”;
menu = [[NSArray alloc] initWithObjects: @”Entrada”, @”Ida para Almoço”,@”Retorno do Almoço”,@”Saída”,nil];

[super viewDidLoad];

// Uncomment the following line to display an Edit button in the navigation bar for this view controller.
// self.navigationItem.rightBarButtonItem = self.editButtonItem;
}

/*
- (void)viewWillAppear:(BOOL)animated {
[super viewWillAppear:animated];
}
*/
/*
- (void)viewDidAppear:(BOOL)animated {
[super viewDidAppear:animated];
}
*/
/*
- (void)viewWillDisappear:(BOOL)animated {
[super viewWillDisappear:animated];
}
*/
/*
- (void)viewDidDisappear:(BOOL)animated {
[super viewDidDisappear:animated];
}
*/

// Override to allow orientations other than the default portrait orientation.
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
// Return YES for supported orientations
return YES;
}

- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning]; // Releases the view if it doesn’t have a superview
// Release anything that’s not essential, such as cached data
}

#pragma mark Table view methods

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
return 1;
}

// Customize the number of rows in the table view.
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
return [menu count];
}

// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

static NSString *CellIdentifier = @”Cell”;

UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
cell = [[[UITableViewCell alloc] initWithFrame:CGRectZero reuseIdentifier:CellIdentifier] autorelease];
}

// Set up the cell…
NSInteger row = indexPath.row;
cell.text = [menu objectAtIndex:row];

return cell;
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
// Navigation logic may go here. Create and push another view controller.
MenuAppDelegate *delegate = [[UIApplication sharedApplication] delegate];

Tela1ViewController *anotherViewController = [[Tela1ViewController alloc] initWithNibName:@”Tela1″ bundle:nil];
[delegate.navigationController pushViewController:anotherViewController animated:YES];
[anotherViewController release];
}

/*
// Override to support conditional editing of the table view.
- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
// Return NO if you do not want the specified item to be editable.
return YES;
}
*/

/*
// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {

if (editingStyle == UITableViewCellEditingStyleDelete) {
// Delete the row from the data source
[tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:YES];
}
else if (editingStyle == UITableViewCellEditingStyleInsert) {
// Create a new instance of the appropriate class, insert it into the array, and add a new row to the table view
}
}
*/

/*
// Override to support rearranging the table view.
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath toIndexPath:(NSIndexPath *)toIndexPath {
}
*/

/*
// Override to support conditional rearranging of the table view.
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath {
// Return NO if you do not want the item to be re-orderable.
return YES;
}
*/

- (void)dealloc {
[super dealloc];
}

@end

Abraços e até a próxima aula.

Olá pessoal. Percebendo a necessidade de algumas pessoas em entender alguns conceitos do Objective-C, estou disponibilizando este tutorial feito por Alberto Martins que encontrei na net. Divirtam-se…

Antes de começar este tutorial gostaria de responder a uma pegunta do Arthur Lopes:
O asterisco no Objective-C tem uma função especial. Ele define a variável como um ponteiro. Os ponteiros são concebidos para armazenar endereços de memória. Com um ponteiro você pode indiretamente manipular os dados armazenados em outras variáveis. Ou seja você cria aquela variável com a referência para outro objeto. Enquanto sem asterisco você cria variáveis por valor.

Ex:
NSArray foo;

Você não deve dizer que foo é um NSArray. Ainda. Ele está apenas pronto para apontar para um (e nesse momento está apontando para NULL “nulo”), até você fazer isto:

foo = new NSArray(…)

Agora foo está apontando para um objeto NSArray.

Você pode ter ponteiros para tipos básicos:

int i = 5; // i é um tipo integer básico
int* x; // x é um PONTEIRO para um integer
x = &i; // x agora aponta para o mesmo espaço de memória que “i” está.

Agora nós podemos referenciar o ponteiro “x” e usar ele para mudar o valor de “i”.

*x = 7; // atribui o valor da variável onde o ponteiro está apontando, para 7

Espero que ajude. Qualquer dúvida procure por “Tipo valor, Tipo referência” no google que vai ter bastante material.

Vamos ao tuto..

Objective-C

Uma iniciação aos conceitos e à linguagem
por Alberto Martins – algol@astro.iagusp.br

Introdução

Este breve tutorial foi criado para suprir a falta de informação sobre a linguagem Objective-C no Brasil, e com isso incentivar sua popularização. Para aqueles que já programam em C, a adaptação ao paradigma de orientação à objetos por meio da linguagem Objective-C ocorre de forma simples e natural, visto que sintaticamente apenas poucas construções são adicionadas. Observamos que no momento este não é um tutorial completo, ou seja, conhecer um pouco de C será não apenas de grande valia, como praticamente necessário para construir programas mais complexos. Devemos salientar também que por enquanto não iremos utilizar o framework “Foundation”, nem qualquer outro, nos mantendo nos rudimentos da linguagem.A linguagem Objective-C foi criada por Brad Cox e sua empresa, a StepStone Corporation, no início da década de 80. Em 88 ela foi licenciada pela NeXT, tornando-se a linguagem de desenvolvimento do NeXTstep. O suporte do GNU/gcc foi acrescentado em 1992. Em 1994 as empresas NeXT Computer e Sun Microsystems criaram uma especificação do NeXTstep conhecida como OpenStep. A implementação da Free Software Foundation da especificação OpenStep é denominada GNUStep.

Atualmente Objective-C é utilizada como a principal linguagem de programação do MacOS X, que é baseado no NeXTstep. A versão da Apple do ambiente NeXTStep/GNUStep com adições é denominada Cocoa.

Características

Objective-C é apenas um conjunto de adições à linguagem C. Ela dá ao C suporte à construções orientadas a objetos como as da Smalltalk.


Objective-C suporta polimorfismo, posing, categorias, e é uma linguagem dinâmica, com typing e binding dinâmicos. Com Objective-C você pode adicionar classes e categorias em tempo de execução de forma fácil. E tudo isso com uma sintaxe de mensagem simples e elegante: olhe os títulos destas subseções e você já saberá como conversar com os objetos!


Objective-C realiza chamadas de mensagem dinâmicas rapidamente, entre 1,5 e 2,0 vezes o tempo de uma chamada de função em C.

Programação Orientada à Objetos

O conceito de orientação à objetos é na verdade algo muito simples. Diariamente utilizamos objetos para realizar tarefas, e programar OO não é nada alem disso.Programadores mais antigos estão acostumados a pensar a programação separando dados e fuções que seriam aplicadas neles. A própria forma de pensar era diferente; para alguns problemas era óbvia a necessidade de uma integração maior entre os dados e as funções, e isto foi o aparecimento do objeto.

Tomando um exemplo simples: supomos que você possua uma televisão. A não ser que você seja um milhonário ou um professor pardal, essa televisão deve ter saído de uma linha de montagem, sendo assim igual a muitos outros aparelhos do mesmo modelo. Entretanto essa é a sua televisão, e ela possui um número de identificação (ou número serial) único.

No exemplo acima e agora traduzindo para o conceito de OO, sua televisão é uma instância da classe televisão. E cada vez que uma nova televisão é produzido, uma nova instância da classe televisão é criada.

Existem também certas coisas que você pode fazer com a sua televisão, como ligar e desligar, modificar o volume e configurações de cor, ligar o PIP, etc. As funções realizadas com a televisão, em OO, denominam-se métodos. Em alguns casos os métodos são aplicados na instância da classe, em outros eles são aplicados na classe em si. Por exemplo, ligar a televisão seria um método de instância e descobrir quantos televisores foram produzidos por um determinado fabricante seria um método de classe.

Quando vamos comprar um televisor em alguma loja, costumamos encontrá-los agrupados junto com tocadores de DVD, por exemplo. Bem, isso não se dá por acaso: televisores, assim como tocadores de DVD são eletrônicos, e com isso possuem características e funções em comum. Podemos então pensar nestes dois aparelhos como sendo instâncias de uma classe denominada eletrônicos. Entretanto não queremos instâncias da classe eletrônicos, e sim das classes televisão e toca-DVD, logo dizemos que as classes televisão e toca-DVD são subclasses (ou classes filhas) da superclasse (ou classe pai) eletrônicos. Esse é um conceito muito importante em orientação à objetos, e é denominado herança: quando criamos uma subclasse ela herda as características e métodos de sua superclasse. Nesse caso podemos dizer que nunca iremos criar uma instância da classe eletrônicos, logo esta é denominada uma classe abstrata, ou seja, uma classe que serve apenas para ser superclasse de outras classes.

Ambiente de programação

Para programar em Objective-C, tal como em qualquer outra linguagem moderna, você precisa de um editor e um compilador. Ambos estão disponíveis gratuitamente em muitos dos sistemas operacionais atuais.No MacOS X, você deve instalar os “Developer Tools” gratuitos da Apple, caso eles não estejam presentes no seu sistema. Essas ferramentas incluem dentre muitas outras coisas o compilador gcc e um ambiente de programação extremamente eficiente, denominado Xcode.

No Linux você já deve ter o gcc instalado, bem como muitos editores de texto (vi, pico, emacs). Você tambem pode utilizar algum ambiente de programação, como o KDevelop ou ferramentas GNUStep.

No Windows você pode instalar o compilador Objective-C que acompanha o sistema MinGW (http://www.mingw.org). Para escrever os códigos, qualquer editor de texto puro, como o Notepad, ou algum ambiente de programação devem servir.

Nos três sistemas, compilar um programa utilizando a linha de comando resume-se ao gcc (para projetos maiores costuma-se utilizar ferramentas como make, automake, etc), cujo formato geral de chamada é:

gcc arquivos.m -o nome_do_programa -l objc

Os arquivos de código da linguagem Objective-C possuem sufixo “.m”, enquanto que os cabeçários possuem, como em C, sufixo “.h”.

Por algum motivo alguem na FSF não parece gostar muito de uma diretriz de pré-processamento (mais sobre isso depois) do Objetive-C denominada “#import”, que serve para substituir “#include” de forma a não ser necessário escrever “#ifndef #define #endif” para não incluir o mesmo arquivo várias vezes, e com isso as versões do gcc utilizadas em computadores com Linux e Windows dão “Warnings” na hora de compilar. Para acabar com esse problema, utilize a chamada do gcc com “-Wno-import”. Computadores com o gcc fornecido pela Apple não sofrem desse problema.

Para compilar programas utilizando o Xcode da Apple você deve criar um novo projeto do tipo “Cocoa Application” e sobrescrever o arquivo “main.m” que será criado automaticamente.

Meu primeiro programa: classes, objetos e métodos

Nesta seção vamos implementar um programa básico, já utilizando conceitos de programação orientada à objetos.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 implementa 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 Gato. Esse dócil animal mia, logo vamos implementar uma classe “Gato” que possui um método chamado “miau” que serve apenas para escrever “Miaau!” na tela. Veja o código:

meuGato.m

//
// Programa Gato
// 
// por Alberto GOK Martins
// para o tutorial de ObjC
//

// aqui comecam as diretrizes do pre-processador
#import <stdio.h>
#import <objc/Object.h>

// aqui comeca a definicao das interfaces
@interface Gato: Object

-(void) miau;

@end

// aqui comecam as implementacoes dos metodos
@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

@end

// aqui comeca o programa
int main( int argc, const char *argv[] )
{
        Gato *meuGato;

        meuGato = [Gato alloc];
        meuGato = [meuGato init];

        [meuGato miau];

        [meuGato free];

        return 0;
}


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 “Gato”, que por enquanto não possui variáveis e apenas um método, o “miau”. Esse é um método da instância da classe “Gato” pois sua declaração é iniciada com o símbolo “-”. Poderíamos também criar um método da própria classe “Gato” utilizando o símbolo “+” para, por exemplo, contar o número de gatos 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 “miau” 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 “meuGato”, dizendo que “meuGato” é um objeto que guardará valores da classe “Gato”. O asterísco diz que “meuGato” é um ponteiro para um “Gato”.

Na segunda linha alocamos espaço na memória para o “meuGato”, e na terceira inicializamos as variáveis que podem estar presentes dentro do “meuGato”. Observe que na segunda linha passamos uma mensagem para a classe “Gato”, enquanto que na terceira a mensagem vai para a instância “meuGato”. 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 “Gato”.

Na quarta linha passamos uma mensagem para o objeto “meuGato”, dizendo para ele miar, ou seja, executar o método “miau” que implementamos.

Na quinta linha passamos uma mensagem para “meuGato” 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 meuGato.m -o meuGato -l objc

Executando o arquivo “meuGato” deve-se obter a seguinte saída:

Miaau!

Um gato mais real…

Vejamos agora um programa um gato um pouco mais elaborado. Todos devemos concordar que os gatos possuem certas características, como cor do pêlo, tamanho, peso, etc. Logo está faltando algo ao nosso gato. No programa a seguir implementamos o peso, bem como funções para defini-lo e obtê-lo; fica para você a tarefa de implementar as outras características.

//
// Programa Gato com caracteristica
// 
// por Alberto GOK Martins
// para o tutorial de ObjC
//

// aqui comecam as diretrizes do pre-processador
#import <stdio.h>
#import <objc/Object.h>

// aqui comeca a definicao das interfaces
@interface Gato: Object
{
        double peso;
}

-(void) miau;
-(void) setPeso: (double) p;
-(double) getPeso;

@end

// aqui comecam as implementacoes dos metodos
@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

@end

// aqui comeca o programa
int main( int argc, const char *argv[] )
{
        Gato *meuGato;
        Gato *meuGato2;

        meuGato = [[Gato alloc] init];
        meuGato2 = [[Gato alloc] init];

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];
        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);

        [meuGato free];
        [meuGato2 free];

        return 0;
}


A primeira adição no programa acima em relação ao original são as declarações dos métodos “setPeso” e “getPeso”. O primeiro recebe um valor real do tipo double, e o segundo retorna um valor tipo double. Estamos prontos para enunciar um formato geral de declaração de métodos:

tipo_de_método(tipo_do_retorno_do_método) nome_do_método: (tipo_do_argumento) argumento;

exemplo de método de classe:

        +(int) quantosGatos;

exemplo de método de instância:

        -(void) setPeso: (double) p;


Na parte de implementação temos as implementações de “setPeso” e “getPeso”.

Na rotina “main” podemos notar que estamos criando dois gatos diferentes. O primeiro pesa 4.2kg, enquanto que o segundo 4.9kg. Devemos observar que, de modo distinto do programa original, estamos alocando memória e inicializando “meuGato” ao mesmo tempo. Essa é uma construção muito utilizada, junto com a alternativa seguinte:

Gato *meuGato = [[Gato alloc] init];


Podemos observar, ainda dentro da rotina “main”, como passar argumentos para o objeto “meuGato”, com o método setPeso. Ou também como obter o valor de uma característica do “meuGato”, com o método “getPeso” e imprimi-lo na tela com a função “printf”.

A saída agora deve ser:

Miaau!
Miaau!
meuGato pesa: 4.200000 kg
meuGato2 pesa: 4.900000 kg

Mais sobre classes, objetos, métodos

Na seção anterior vimos como passar um argumento para um método. Entretanto muitas vezes é desejável poder passar mais do que um argumento por vez, por exemplo para definir a posição (x,y) de um ponto no R². Felizmente existe um tipo de construção que nos permite fazê-lo:

-(tipo) nome: (tipo) variável nome: (tipo) variável;

exemplo, um método para definir as posições de um ponto no R2:

-(void) setX: (double) x andY: (double) y;

passando a mensagem:

[Objeto setX: 1.511 andY: 2.332];

Geralmente é interessante ter métodos para definir cada argumento separadamente, ainda que existam os métodos para definir múltiplos argumentos de uma só vez.

Um método também pode retornar um objeto. Por exemplo, poderíamos implementar um método de instância na classe “Gato” que definisse uma reprodução sexuada. Para isso temos que ter duas instâncias da classe “Gato” allocadas e inicializadas; uma para receber a mensagem e outra para ser o objeto a ser recebido como argumento da mensagem. Devemos ter também um objeto do tipo “Gato”, que armazenará o gato filho. Acompanhe a definição do método “reproduzir”:

<novo método>
-(Gato *) reproduzir: (Gato *) Gato2
{
        // funcao para criar um gato filho com a media dos pesos dos pais
        // antes de algum protesto, nao estamos tentando ser biologicamente corretos!

        Gato *Gatinho=[[Gato alloc] init];
        double pesoGatinho;

        pesoGatinho = (peso+[Gato2 getPeso])/2;

        [Gatinho setPeso: pesoGatinho];

        return Gatinho;
}

<novo main>
int main( int argc, const char *argv[] )
{
        Gato *meuGato = [[Gato alloc] init];
        Gato *meuGato2 = [[Gato alloc] init];
        Gato *meuGatoFilho;

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];

        meuGatoFilho = [meuGato reproduzir: meuGato2];
        [meuGatoFilho miau];

        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);
        printf("meuGatoFilho pesa: %lf kg\n",[meuGatoFilho getPeso]);

        [meuGato free];
        [meuGato2 free];
        [meuGatoFilho free];

        return 0;
}

Em Objective-C você pode se referir ao próprio objeto que está recebendo a mensagem, usando para isso a palavra “self”. Isso tem muitas utilidades, por exemplo para executar um método que precise executar outros métodos. Um exemplo não muito bom seria criar um método “comer” para o nosso gato que utilizasse o método “setPeso” (como [self setPeso: 5]) para engordá-lo; nesse caso poderíamos alterar o valor de “peso” sem recorrer ao “self”, porém caso tivéssemos algum método que realizasse muitas tarefas isso seria de grande utilidade.

Agora uma dica de organização: tipicamente os programadores dividem suas classes em arquivos separados, nomeados “classe.h” e “classe.m”; o primeiro contém a seção “@interface” e o segundo “@implementation”. O arquivo de interface diz ao compilador como a sua classe é, enquanto que o arquivo de implementação contém o código verdadeiro da classe.

Para realizar ligar os diversos arquivos devemos compilar o programa de uma forma especial, bem como nos utilizar da diretriz de pré-processamento “#import”. Observe a nova implementação do programa do gato:

Gato.h

//
// Classe Gato - interface
// 
// por Alberto GOK Martins
// para o tutorial de ObjC
//

#import <objc/Object.h>

@interface Gato: Object
{
        double peso;
}

-(void) miau;
-(void) setPeso: (double) p;
-(double) getPeso;
-(Gato *) reproduzir: (Gato *) Gato2;

@end

Gato.m

//
// Classe Gato - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import <stdio.h>
#import "Gato.h"

@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

-(Gato *) reproduzir: (Gato *) Gato2
{
        // funcao para criar um gato filho com a media dos pesos dos pais
        // antes de algum protesto, nao estamos tentando ser biologicamente corretos!

        Gato *Gatinho=[[Gato alloc] init];
        double pesoGatinho;

        pesoGatinho = (peso+[Gato2 getPeso])/2;

        [Gatinho setPeso: pesoGatinho];

        return Gatinho;
}

@end

main.m

//
// Programa Gato com caracteristica
// em multiplos arquivos
//
// por Alberto GOK Martins
// para o tutorial de ObjC
//

#import <stdio.h>
#import "Gato.h"

int main( int argc, const char *argv[] )
{
        Gato *meuGato = [[Gato alloc] init];
        Gato *meuGato2 = [[Gato alloc] init];
        Gato *meuGatoFilho;

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];

        meuGatoFilho = [meuGato reproduzir: meuGato2];
        [meuGatoFilho miau];

        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);
        printf("meuGatoFilho pesa: %lf kg\n",[meuGatoFilho getPeso]);

        [meuGato free];
        [meuGato2 free];
        [meuGatoFilho free];

        return 0;
}

Preste especial atenção em como a diretiva “#import” é utilizada. O arquivo “Gato.h” precisa de informações sobre a classe “Object” que foi definida no arquivo “objc/Object.h”, e por isso devemos importá-lo em “Gato.h”. Já o arquivo “Gato.m” deve importar o arquivo de interface de sua classe, o “Gato.h”, bem como “stdio.h”, pois utiliza a função “printf”. Finalmente, o programa principal deve importar o arquivo “stdio.h” pela função “printf” e o arquivo “Gato.h” por instanciar objetos da classe “Gato”. Isso pode parecer um pouco confuso, mas na verdade o conceito é bastante simples: deve-se importar tudo o que for utilizar.

Para compilar programas com multiplos arquivos no gcc, use a seguinte linha de comando:

gcc arquivo1.m arquivo2.m main.m -o nome_do_programa -l objc

no caso do nosso programa, use:

gcc Gato.m main.m -o gato -l objc

execute o programa e veja o resultado; ele deve ser similar ao apresentado abaixo:

Miaau!
Miaau!
Miaau!
meuGato pesa: 4.200000 kg
meuGato2 pesa: 4.900000 kg
meuGatoFilho pesa: 4.550000 kg

Herança

Nesta seção falaremos sobre um dos conceitos mais importantes da programação orientada a objetos: a herança.Uma classe pode ter a si mesma como superclasse, e essa classe, que não possui superclasse é denominada classe raiz (ou root). A classe raiz pode ser programada por você mesmo, ou então como é mais comum, ser a classe Object, descrita em “objc/Object.h” ou a classe NSObject, descrita em “Foundation/NSObject.h”.

A classe que foi criada neste tutorial é uma subclasse de Object, e com isso ela herda certos métodos, como free e outros que foram definidos para a classe Object. No entanto suponha que agora seja necessário criar um classe para cachorros. Bem, poderíamos criar uma subclasse de Object denominada Cachorro e implementar funções como setPeso e getPeso idênticas às da classe Gato. Uma solução melhor, seria criar uma subclasse de Object denominada Animal, e as classes Cachorro e Gato seriam subclasses da classe Animal, que por sua vez seria uma classe abstrata, visto que nunca iremos criar uma instância de Animal.

No exemplo abaixo fizemos justamente isso.

Animal.h

//
// Classe Abstrata Animal - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import <objc/Object.h>

@interface Animal : Object
{
        double peso;
}

-(void) setPeso: (double) p;
-(double) getPeso;

@end

Animal.m

//
// Classe Abstrata Animal - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

@implementation Animal

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

@end

Gato.h

//
// Classe Gato - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

// aqui comeca a definicao das interfaces
@interface Gato: Animal

-(void) miau;

@end

Gato.m

//
// Classe Gato - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Gato.h"
#import <stdio.h>

// aqui comecam as implementacoes dos metodos
@implementation Gato

-(void) miau
{
        printf("Miaau!\n");
}

@end

Cachorro.h

//
// Classe Cachorro - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

// aqui comeca a definicao das interfaces
@interface Cachorro: Animal

-(void) auau;

@end

Cachorro.m

//
// Classe Cachorro - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Cachorro.h"
#import <stdio.h>

// aqui comecam as implementacoes dos metodos
@implementation Cachorro

-(void) auau
{
        printf("AuAu!\n");
}

@end

main.m

//
// Programa de Animais com heranca
//
// por Alberto GOK Martins
// para o tutorial de ObjC
//

#import <stdio.h>
#import "Gato.h"
#import "Cachorro.h"

// aqui comeca o programa
int main( int argc, const char *argv[] )
{
        Gato *meuGato = [[Gato alloc] init];
        Gato *meuGato2 = [[Gato alloc] init];
        Cachorro *meuCachorro = [[Cachorro alloc] init];
        Cachorro *meuCachorro2 = [[Cachorro alloc] init];

        [meuGato setPeso: 4.2];
        [meuGato2 setPeso: 4.9];
        [meuGato miau];
        [meuGato2 miau];

        printf("meuGato pesa: %lf kg\n",[meuGato getPeso]);
        printf("meuGato2 pesa: %lf kg\n",[meuGato2 getPeso]);

        [meuCachorro setPeso: 10.2];
        [meuCachorro2 setPeso: 13.3];
        [meuCachorro auau];
        [meuCachorro2 auau];

        printf("meuCachorro pesa: %lf kg\n",[meuCachorro getPeso]);
        printf("meuCachorro2 pesa: %lf kg\n",[meuCachorro2 getPeso]);

        [meuCachorro free];
        [meuCachorro2 free];
        [meuGato free];
        [meuGato2 free];

        return 0;
}

Observe que no exemplo acima o método “reproduzir” nao existe mais. Optamos por não escrevê-lo, pois embora essa seja uma atividade comum para todos os animais a reprodução de animais diferentes deve gerar objetos de classes diferentes, e não um animal genérico da classe animal. Para contornar o problema você poderia escrever dois métodos, um para cada classe, denominados “reproduzir”, que embora partilhassem o mesmo nome seriam um pouco diferentes; afinal você não espera que um casal de cachorros gerem filhos gatos. Implementar um método comum exigirá um pouco mais de conhecimento, e isso será realizado na próxima seção, denominada Polimorfismo, Typing dinâmico e Binding dinâmico.

Suponha agora que você queira que o método getPeso para um gato retorne o peso em gramas e não em quilos. Bem, você pode modificar a implementação original de getPeso na clase Animal, porém isso modificará também o retorno do getPeso para cachorros. Para solucionar este problema pode-se utilizar um conceito denominado overriding.

Overriding é simplesmente sobrescrever um método. Quando você cria um método com o mesmo nome de um outro método que foi herdado pela classe, vale o método da classe e não o da superclasse. Logo, você poderia criar um método dentro da classe Gato com o mesmo nome (no caso, getPeso) e com isso apenas o método da classe Gato seria afetado, permitindo que a classe Cachorro continuasse retornando o peso em kilogramas. Experimente, realizando overriding de getPeso da classe Gato (não esqueça de modificar o printf da rotina main para escrever “g” ao invés de “kg”).

Dentro de classes podemos também instanciar objetos. Por exemplo, suponhamos que todos os animais (logo todas as subclasses da classe Animal – novamente, não estamos tentando ser biologicamente corretos!) tenham olhos. Podemos então, definir uma classe denominada Olho, e instanciá-la dentro da classe Animal. Observe a interface e implementação da classe Olho, bem como os novos arquivos da classe Animal.

Olho.h

//
// Classe Olho - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import <objc/Object.h>

@interface Olho : Object
{
        int estado_da_pupila;
}

-(void) setEstado_Da_Pupila: (int) pupil;
-(void) printEstado_Da_Pupila;

@end

Olho.m

//
// Classe Olho - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Olho.h"

@implementation Olho

-(void) setEstado_Da_Pupila: (int) pupil
{
        if(pupil==0) estado_da_pupila=0;
        if(pupil==1) estado_da_pupila=1;
        if(pupil==2) estado_da_pupila=2;
}

-(void) printEstado_Da_Pupila
{
        if(estado_da_pupila==0)
        {
                printf("A pupila está contraída\n");
        }
        if(estado_da_pupila==1)
        {
                printf("A pupila está normal\n");
        }
        if(estado_da_pupila==2)
        {
                printf("A pupila está dilatada\n");
        }
}

@end

Animal.h

//
// Classe Abstrata Animal - interface
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import <objc/Object.h>
#import "Olho.h"

@interface Animal : Object
{
        double peso;
        Olho *AOlho;
}

-(void) setPeso: (double) p;
-(double) getPeso;
-(void) printEstado_Da_Pupila;
-(void) setEstado_Da_Pupila: (int) edp;

@end

Animal.m

//
// Classe Abstrata Animal - implementacao
//
// por Alberto GOK Martins
// para o tutorial de Objc
//

#import "Animal.h"

@implementation Animal

-(void) setPeso: (double) p
{
        peso=p;
}

-(double) getPeso
{
        return peso;
}

-(void) printEstado_Da_Pupila
{
        // funcao para imprimir o estado da pupila de um animal

        if(AOlho)
               [AOlho printEstado_Da_Pupila];
        else
                printf("Não foi definido um estado da pupila deste animal.\n");
}

-(void) setEstado_Da_Pupila: (int) edp
{
        [AOlho free];
        AOlho = [[Olho alloc] init];
        [AOlho setEstado_Da_Pupila: edp];
}

@end

O código que deve ser utilizado para testar o funcionamento do Olho em main.m é:

[meuGato setEstado_Da_Pupila: 1];
[meuGato printEstado_Da_Pupila];

Obtivemos agora um enorme problema. Como é que vamos liberar a memória alocada para o Olho do Animal? Como não podemos acessar diretamente o objeto AOlho não podemos liberar a memória sem criar um método pertencente à classe Animal específico para isso; ou então, como saída mais inteligente, realizar um overriding do método free.

Caso não liberemos a memória teremos um problema que se denomina vazamento de memória, ou memory leakage. Bem, para realizar o overriding de free precisamos saber como liberar a memória alocada pelo próprio objeto, no entanto como o método free é agora diferente do original ele não mais saberá como liberar a memória alocada para o objeto. A saída para isso é a instrução super que se refere a classe pai do recebedor da mensagem. Super chamará não o método da classe atual, mas aquele que foi herdado. Desta forma podemos sempre nos referir ao método antigo de todos os métodos que foram implementados através de overriding.

Logo a implementação do método free para a classe Animal deve ser:

-(id) free
{
        [AOlho free];
        return [super free];
}

Deixaremos para nos preocupar com a palavra id na próxima seção

Polimorfismo, Typing dinâmico e Binding dinâmico

Polimorfismo é um conceito muito simples. Ele nada mais é do que a habilidade que uma linguagem orientada à objetos tem de definir métodos com o mesmo nome para classes diferentes. Cada definição de classe guarda o código necessário para seus métodos.Typing dinâmico é a característica que a linguagem tem de poder postergar a determinação da classe de um objeto até o tempo de execução do programa, enquanto que Biding dinâmico é poder postergar a determinação do método que será invocado em um objeto até o tempo de execução.

Para realizar o typing e o binding dinâmicos utiliza-se o tipo id. Este é um tipo de objeto genérico, que pode ser utilizado para guardar objetos pertencentes a qualquer classe. Na seção anterior utilizamos o tipo id para realizar o overriding do método free. Vejamos agora, como implementar o método reproduzir na classe Animal, e permitir que a classe Gato e Cachorro se reproduzam, sem que seja necessário criar dois métodos distintos:

-(id) reproduzir: (id) Animal2
{
        // funcao para criar um animal filho com a media dos pesos dos pais
        // antes de algum protesto, nao estamos tentando ser biologicamente corretos!
        // existe um teste para verificar se os animais sao da mesma classe.

        id Filho=[[[self class] alloc] init];

        if ([self class] == [Animal2 class])
        {
                printf("O filho nasceu sadio!\n");
                [Filho setPeso: (peso+[Animal2 getPeso])/2];
        }
		else
        {
                printf("O filho nasceu morto, pois os pais são de classes diferentes!\n");
                [Filho setPeso: 0];
        }
        return Filho;

}


Na implementação da função acima utilizamos o tipo id, pois não sabemos qual será a subclasse de Animal que será passada nem a classe que irá retornar. Utilizamos também a palavra self que serve para se referir ao próprio objeto, logo dizer [self class] é uma forma de pedir para o objeto retornar a própria classe; no método reproduzir precisamos criar um filho da mesma classe dos pais, logo usamos [self class] como a classe do filho.

Últimas palavras

Esse tutorial deve ser aprimorado, com o passar do tempo e com sua ajuda. Por favor, não deixe de enviar um email dizendo o que achou, se conseguiu aprender alguma coisa ou se não conseguiu aprendeu nada.Por enquanto é isso. Após essas seções estarem melhor talhadas, pretendo incluir outros tópicos, como C-básico, posing, categorias e a utilização básica do framework Foundation. Entretanto, enquanto esses aprimoramentos não vem, e caso você queira se aprofundar na linguagem eu sugiro os links e referências presentes na seção Referências e links.

Referências e links

Apple Objective-C Manual
GNU Objective-C Manual
comp.lang.Objective-C FAQ
Programming in Objective-C, Stephen Kochan. Sams Publishing, 2004.

The C Programming Language, Brian W. Kernighan e Dennis M. Ritche. Prentice Hall, Inc., 1988.

GNUstep

Página por Alberto G. O. K. Martins – algol@astro.iag.usp.br
Design based on the Dekorte’s Objective-C webpage. CSS additions by Alberto G. O. K. Martins.
Qualquer contribuição, alteração, comentário ou sugestão, favor enviar para o email algol@astro.iag.usp.br.

Fala gente. Esta semana estou preso com um projeto e não está dando tempo de terminar o tuto. Espero até o fim desta semana colocar algo bom no ar. Enquanto isso, vamos nos informar com este preview do iphoneOS 3.0 que trará muitas melhorias para nós desenvolvedores. Abraços…

A nova versão do sistema operacional do iPhone trará muitas novidades esperadas, como suporte a copy e paste, MMS, busca, conexão P2P, Bluetooth estéreo, uso de recursos de mapas em aplicativos e notificações via push, entre mais de 100 modificações.

A companhia apresentou as novidades do iPhone OS 3.0 para uma platéia em Cupertino, na Califórnia. O evento foi transmitido ao vivo por sites especializados em tecnologia, como o Engadget.

Uma das novidades mais esperadas, a função de copy e paste foi confirmada. A recurso deve funcionar entre aplicações, o que significa que é possível copiar um texto do aplicativo Notes, por exemplo, e colar em um e-mail. Torpedos SMS, textos de aplicativos e até fotos também podem ser recortados, copiados e colados.

Os botões da caixa de cópia de texto permitem expandir ou retrair a área de seleção. Se você errar, basta chacoalhar o aparelho que a última ação será desfeita.

Finalmente, as mensagens multimídia (MMS) – como fotos, áudio e vídeo – serão suportadas pelo iPhone. O aplicativo de torpedos também ganha novas funções, como a possibilidade de encaminhar mensagens e deletar SMSs em grupo.

A usabilidade do aparelho também deve melhorar com novidades como busca e teclado em modo de paisagem para e-mails e outros aplicativos.

Aplicações mais ricas

Os desenvolvedores também foram beneficiados com novos recursos para seus aplicativos. A primeira função apresentada foi o pareamento de iPhones que estejam próximos via Bluetooth. O recurso de P2P não permitirá troca de arquivos, apenas interação no uso de aplicativos – como jogos, por exemplo – e poderá ser usado pelos desenvolvedores em seus programas.

Outra novidade é a criação de uma API pela Apple e pelo Google para que os desenvolvedores possam usar mapas em seus aplicativos. A Apple comunicou ainda que o novo sistema permitirá aos programadores o envio de notificações via push (em tempo real) para os usuários de seus softwares.

Por fim, na nova versão do sistema os desenvolvedores poderão vender conteúdos de dentro dos aplicativos – atualizações de jogos com novas fases ou conteúdos noticiosos, por exemplo.

“O objetivo é abrir caminho para uma série de inovações no aparelho”, explica Fábio Ribeiro, engenheiro de sistemas da Apple no Brasil.

Disponibilidade

Infelizmente, algumas das novidades – como MMS e Bluetooth estéreo – não rodarão na versão clássica do iPhone, devido a limitações de hardware.

A atualização do software será gratuita para os atuais usuários do iPhone e deve chegar no verão dos Estados Unidos, que vai de junho a setembro. Usuários do iPod touch terão que pagar US$ 9,95 pela nova versão do sistema.

Os desenvolvedores registrados no programa da Apple para vender aplicativos terão acesso imediato ao beta e ao kit de desenvolvimento (SDK) do novo sistema.

Olá pessoal. Vamos agora para a segunda parte sobre interação no iPhone. Vamos também iniciar agora com tutoriais em video para melhorar a dinâmica de aprendizagem. Vamos lá..

Bom, continuando a aula anterior vamos explicar aqui pra que serve a declaração @property.
Se você trabalha com o Objective-C 2.0, você provavelmente está familiarizado com a declaração @property, mas se não está, esta linha de código pode intimidar. Não tema: Propriedades no Objective-C são realmente simples. Deixe me pegar o rápido desvio, pois essa decoração vai ser usada constantemente nesse curso.

Propriedades no Objective-C

Antes da declaração @property ter sido somada no Objective-C, programadores tradicionalmente definiam pares de métodos para atribuir e recuperar valores de cada variável de uma estância de classe. Esses métodos são chamadas de acessors e mutators. (Ou se preferir, getters e setters) e podem se parecer com isso:

- (id) foo
{
return foo:
}

- (void) setFoo: (id) _foo
{

if (_foo != foo)
{

[_foo retain];
[foo release];
foo = _foo;
}

}

Sendo esta representação perfeitamente válida, a declaração @property permite que você diga adeus ao tedioso processo de criação de métodos acessors e mutators, se você quiser. O @property não trabalha sozinha, combinado com outra declaração no arquivo de implementação (@synthesize), que você deve ver em alguns instantes, dirão ao compilador para criar os métodos getter e setter em tempo de compilação. Você deve ter que declarar uma variável de instancia como foi feito aqui, mas você não precisa definir o accessor e o mutator.

Em nossa declaração, o @ property chamar alguns atributos opcionais, separado por parêntese. Este ponto define como os acessors e mutators serão criados pelo compilador. Os dois que você verá aqui serão usados quando definirmos as propriedades na aplicação do iPhone.

@property (retain, nonatomic) UILabel *statusText;

O primeiro dos atributos, retain, diz ao compilador para enviar uma mensagem retain para o objeto que está assinando a propriedade. Este irá deixar a variável de instância com um marcação para ser acessado diretamente da memória quando nós precisamos dele. Isto é necessário por causa do comportamento padrão (assign) que é concebido para ser usado com a coleção Garbage, um recurso do Objective-C que atualmente não está implementado no iPhoneOS. Como resultado, se você definir uma propriedade que é um objeto (como um inteiro), você deverá gerar um retain especifico no atributo opcional. Colocando um “@property (retain” ao declarar a propriedade para um int, float, o outro tipo de dado raw, você não precisará especificar nenhum atributo opcional.

O segundo dos nossos atributos opcionais, nonatomic, muda a forma que os métodos acessors e mutators são gerados. Sem ser muito técnico, apenas deixe-me dizer que, por padrão, esses métodos são criados com algum código adicional que auxilia quando estiver escrevendo programas multitarefas (que não é feito atualmente no iPhone). Este código adicional, embora pequeno, é desnecessário quando estiver declarando um ponteiro para um objeto de interface com usuário então nós declaramos nonatomic para salvar um pouco de ciclos do processador. Haverá vezes que você não vai querer especificar um nonatomic para uma propriedade. Como regra geral, você irá especificar esse atributo na maioria das vezes que estiver escrevendo aplicações iPhone.

Propriedades no Objetive-C tem outro recurso legal. Eles introduzem ao uso de notação de ponto para a linguagem. Tradicionalmente, para usar um método accessor, você deve enviar uma mensagem para o objeto, como esta:

myVar = [algumObjeto foo];

Esta abordagem irá trabalhar corretamente. Mas quando você definir uma propriedade, você também tem a opção de usar a notação de ponto, similar ao que é usado em Java, C++ e C#, desta forma:

myVar = algumObjeto.foo;

Essas duas representações são idênticas para compilador. Use aqui te deixar mais feliz . Notação de ponto também trabalha com mutator:

algumObjeto.foo = myVar;

É idêntico a:

[algumObjeto setFoo: myVar];

Somando Actions e Outlets para o arquivo implamatation

Depois de termos alterado nosso cabeçalho da classe controller, salve-o e de apenas um cliente no arquivo de classe de implementação, Button_FunViewController.m

Neste ponto acho melhor vermos o vídeo que fiz para termos um entendimento maior, OK?

Abaixo segue o código do arquivo button_FanViewController.m depois de alterado:

Olá pessoal. Neste capítulo vamos aprender sobre como interagir um pouco mais com o usuário. E para isso vamos construir nossa primeira aplicação usando o Interface Builder que vamos a partir de agora chamar carinhosamente de IB. Mas antes acho prudente falar também de algumas limitações quando se programa para dispositivos móveis. Bom aprendizado.

Bom, vamos começar a descrever as limitações no que diz respeito a desenvolver para iPhone:

O paradigma MVC

Antes de iniciarmos, precisamos de um pouco de teoria. Os designers do Cocoa Touch foram guiados por um conceito chamado Model-View-Controller (ou MVC), que é o caminho mais lógico de dividir o código da interface gráfica. Nos dias atuais todos os frameworks pegam um pouco da lógica MVC, mas nenhum outro como o Cocoa Touch.

O modelo MVC divide todas as funcionalidades em três categorias distintas:

• Model: São as classes de sua aplicação que acessam dados;
• View: Contém seus Windows, controls, e outros elementos que o usuário possa interagir;
• controller: liga o Model ao view e é a parte lógica da aplicação que decide como manipular as entradas do usuário.

A meta no MVC é fazer que os objetos que implementam esses três tipos de código serem diferentes um do outro quanto possível. Qualquer objeto que você escreva o terá que ser identificado em uma dessas três categorias, com pequena ou nenhuma funcionalidade e que o fizesse estar classificada nas outras duas.

Em um objeto que implementamos um botão, por exemplo, não se deve conter códigos para processar dados quando este botão é pressionado, e o código que implementa uma conta de banco não deve desenhar a tabela que mostra esta transação.

O MVC ajuda a você a ter o máximo de reusabilidade. A classe que implementa um botão genérico pode ser usada em qualquer aplicação. A classe que implementar um botão que faz um cálculo particular só podem ser usados na aplicação que originalmente foi escrito.

Quando você escreve aplicações Cocoa Touch, você irá primeiramente criar seus componentes View usando o interface builder, você poderá também algumas vezes modificar sua interface pelo código, ou você poderá instânciar existentes views e controls.

O seu Model será criado pelas classes do Objective-C que você criar e que são específicas para a sua aplicação. Mas não estaremos criando nenhum objeto Model neste capítulo, porque nós não precisamos guardar ou preservar dados, mas nós iremos introduzir objetos Model quando nossa aplicação ficar mais complexa em futuros capítulos.

Seu componente controller estará tipicamente compreendida nas classes que você criar e que são específicas para a sua aplicação. Controllers podem ser completamente customizadas, mas eles oferecem mais, eles podem ser istanciadas dia existentes classes de controles genéricos do UIKit framework como o UIViewController, que você verá em alguns instantes. Istanciando uma dessas existentes classes, você irá pegar um monte de funcionalidades gratuitamente a que não terá de perder tempo reinventando a roda, como dizem.

Quando nós nos aprofundarmos no Cocoa Touch, você irá rapidamente começar a ver como as classes do framework UIKit segue os princípios da MVC. Se você colocar este conceito dentro de sua cabeça de desenvolvedor, você irá melhorar seu código e verá que ficará mais fácil mantê-lo.

Criando nosso projeto

Desta vez para criar o nosso projeto Xcode. Nós iremos usar um diferente template: view-based Application. Vamos em frente criar o nosso projeto, salve-o com o nome de Button_Fun. Se você tiver algum problema criando seu projeto, referencie o procedimento do capítulo anterior.

Você provavelmente se lembrar que o projeto foi criado com algumas classes para nós. Você irá encontrar as mesmas classes neste projeto apenas os nomes que serão um pouco diferente por causa dos nomes das classes serem baseadas no nome do projeto.

Criando o View controller

Um pouco depois deste capítulo, nós iremos desenhar um View (ou interface de usuário) para nossa aplicação usando o interface Builder, como nós dissemos no último capítulo. Antes de nós fazemos isso, nós iremos dar uma olhada e fazer algumas mudanças no código que foi criado automaticamente para nós.

Estes quatro arquivos implementam 2 classes, cada uma contém um .m e .h arquivo. Aplicação que nós iremos criar neste capítulo tem somente um View, e a classe controller que é responsável pelo gerenciamento é chamada Button_FunxiewController Clique no Button_FunViewController.h e dê uma olhada no conteúdo arquivo:

#import <UIKit/UIKit.h>
@interface Button_FunxiewController: UIViewController {

}
@end

Não é muito. Essa é uma estância do UIViewController, que é uma das classes de controles genéricos que nós mencionamos anteriormente a. Ele faz parte do UIKit e nos dá um range de funcionalidades gratuitamente. Os Xcode não sabe que funcionalidade específica nossa aplicação do irá fazer, ele só sabe que irá fazer alguma coisa, então ele cria esta classe para essa funcionalidade genérica.

Nosso programa consiste em dois botões e uma caixa de texto que reflete qual botão nós apertamos. Mas criaremos todos esses três elementos no interface Builder. Desde que nós também iremos escrever um código, ele deve ter alguma forma de interagir com seu código a interagir com os elementos criados no interface Builder, certo?

Absolutamente certo. Nossa classe controller pode referenciar objetos do interface Builder usando uma especial porção de variáveis de instâncias chamadas de “Outlet”. Pense no Outlet como um ponteiro que aponta para um objeto do nib. Por exemplo, suponha que você crie uma caixa de texto no interface Builder e queira chamar essa caixa de texto pelo seu código. Para declarar um outlet para o objeto label, você deve usar o outlet dentro do seu código para mudar o objeto label. Você verá como fazer isso daqui a pouco.

Indo em outra direção, objetos de interface no nosso arquivo “nib” pode ser configurado para chamar métodos especiais na nossa classe controller. Só que esses métodos especiais são conhecidos como os métodos de ação “Action”. Por exemplo, você pode dizer o interface Builder que quando o usuário tocar no botão, um método especifico do código deve ser chamado.

Nosso próximo exemplo irá atribuir dois botões e um label.

No nosso código, iremos criar um outlet que aponta para o label, e este outlet irá permitir mudar o texto do label. Nós também criaremos um método chamado buttonPressed: que irá acionar quando um dos dois botões forem tocados . buttonPressed: irá configurar a propriedade texto do label dizendo ao usuário que botão ele apertou.

Nós usaremos o interface Builder para criar os botões e eu label, e depois nós faremos alguns cliques e arrastar e soltar para conectar o label ao nosso label Outlet e nossos botões a nossa ação buttonPressed.

Mas antes vamos mexer no código, mas daremos um pouco mais de detalhes sobre os Outlets e os Actions.

Outlets

Outlet são variáveis de instância e são declaradas usando a palavra chave IBOutlet. A declaração de um Outlet fica no cabeçalho do seu arquivo controller “.h” que pode se parecer com isso:

IBOutlet UIButton *myButton;

A palavra chave IBOutlet é definida desta forma:

#ifndef IBOutlet
#define IBOutlet
#endif

Confuso? IBOutlet Não faz absolutamente nada em que o compilador esteja envolvido. Ele é feito propositalmente o para agir como uma dica ao interface Builder que esta é uma variável de instância que nós iremos conectar a um objeto em um nib. Qualquer variável de instância que você crie e quiser conectar a um objeto no arquivo nib deve ser precedida de um IBOutlet. Quando você abrir o interface Builder, ele irá procurar os seus arquivos de cabeçalho do projeto a ocorrência dessa palavra chave em irá permitir a você fazer conexões do seu código para a sua variável nib equivalente. Em alguns minutos, você verá como atualmente se faz uma conexão em entre o Outlet e um objeto de interface de usuário com interface Builder.

Actions

Actions São métodos que fazem parte de sua classe controller. Eles são também declarados com uma palavra chave especial , IBAction, que xiz ao interface Builder que este método é uma ação e pode ser provocado por um controle. Tipicamente, é o a declaração de um método Action irá se parecer com isso:

- (IBAction) fazAlgumaCoisa:(id)sender;

O atual nome do método pode ser qualquer coisa que você quiser, mas ele deve retornar um tipo “IBAction”, que é o mesmo que declarar um tipo de retorno “void”. Esta é outra forma de dizer que o método Action não retorna valor algum. Usualmente, o método Action irá pegar um argumento, e será tipicamente definido como id e também dará o nome de quem solicitou (sender). O controle que provoca a sua ação usar o argumento “sender” para passar a referência dele mesmo. Então, por exemplo, se seu método Action foi chamado pelo resultado de um toque no botão, o argumento “sender” deverá conter a referência para o botão específico que foi apertado.

Como você verá, o nosso programa irá usar o argumento sender para configurar o label com texto esquerda e direita, dependendo do botão que você apertar. Se você não precisa saber qual o controle chamou seu método, você pode também definir o método Action sem um parâmetro “sender”. Ele deve se parecer com isto:

- (IBAction) fazAlgumaCoisa;

Você não precisa se preocupar se você declarar um método Action com um argumento “sender” e ignorar o “sender”. Os métodos Action do Cocoa aceitam o sender sendo usados ou não.

Somando Actions e Outlets no seu View controller

Agora que você sabe o que Outlets e Actions são, vamos ao cabeçalho somar cada uma de nossas classes de controle. Nós precisaremos de um Outlet para podermos mudar o label. Nós não vamos querer mudar nada nos botões, nós não precisaremos de Outlet para eles.

Nós iremos declarar um único método Action que será chamado por ambos os botões. Quando muito os métodos Action são chamados por um único controle, é possível usar a mão única ação para manipular entradas de múltiplos controles, que é o que nós vamos fazer aqui. Nosso Action irá pegar o nome do Butão e colocar no argumento sender e usar o Outlet do label para inserir no nome do botão na propriedade ”text” do label.

Vamos agora somar o seguinte código no Button_FunViewController.h:

Nota: O que tiver em negrito é o que está sendo somado.

#import <UIKit/UIKit.h>
@interface Button_FunxiewController: UIViewController {

IBOutlet UILabel *statusText;
}
@property (retain, nonatomic) UILabel *statusText;

- (IBAction) buttonPressed: (id)sender;
@end

Bom gente, acho que já tem muito texto para um Capítulo só. Desculpem tanta teoria, mas sem ela não irá ter pernas para caminhar por outras veredas. Nesta semana ainda termino a outra parte do nosso projeto. Consegui uma forma mais rápida de fazer estes tutoriais e pretendo adiantá-los bastante. Abraços.

Olá galera. Apesar de estar muito ocupado na empresa, estou de volta com algum aprendizado sobre o XCODE. Daremos uma vistoriada geral nesta fantástica aplicação que tem tudo que precisamos para fazermos aplicações para o iPhone. Boa aula.

Introdução ao XCODE

Programar para Apple começa com o XCODE, é um ambiente integrado de desenvolvimento ( mais conhecido por IDE), que pode ser chamado a partir do diretório do desenvolvedor.

Para escrever programas para iPhone, você deve ter baixado o iPhone SDK, como discutido nos capítulos anteriores. Depois de feito isso, escolha Arquivo> Novo projeto irá abrir um wizard para ajudar a criar seu projeto.

Você vai ser imediatamente solicitado a selecionar um modelo para o seu novo projeto. O modelo que você escolher vai preencher o seu projeto com o framework padrão, arquivos padrões, objetos padrões, e sempre o mesmo código padrão. Como você vai ver, vai ser uma grande ajuda para iniciar o seu próprio código. Para o seu primeiro programa, quero começar com o mais simples modelo que podemos encontrar: Window-Based Application.
Depois de selecionar um modelo, você precisará também do nome do seu projeto e escolher onde salvá-lo, depois que você tiver feito isso, você está pronto para iniciar a codificação. Antes de chegarmos lá, porém, vamos dar uma olhada mais de perto na forma de trabalho do ambiente XCODE.

A Anatomia do XCODE

Quando acionado, o XCODE exibe apenas uma janela.  Onde aparece o nosso primeiro projeto, helloworld.

Como você pode ver, a janela principal do Xcode compreende três partes.

Na esquerda tem uma barra lateral que contém uma listagem de todos os arquivos que estão sendo usados no seu projeto, organizados por tipo. Sempre que você precisar adicionar frameworks, imagens, bases de dados, ou outros arquivos para seus projetos, você vai fazê-lo aqui. O painel esquerdo contém também alguns outros elementos úteis, em especial um item de Errors and Warnings (Erros e avisos) que você pode clicar em abrir para ver rapidamente os problemas na sua compilação.

O topo-direito contém um painel com uma lista de arquivos desagrupados usado pelo seu projeto. Quando você clica em um desses, o seu conteúdo será exibido no painel inferior direito. Como você pode ver, mesmo o mais simples programa irá incluir mais de uma meia-dúzia de arquivos.

O que é cada um deles.

Neste capítulo iremos focar exclusivamente nos cabeçalhos e arquivos de código fonte. No próximo capítulo iremos expandir o nosso trabalho para incluir também o arquivo do Interface Builder “.xib”.

Compilando e Executando no XCODE

Para compilar no Xcode, escolha Build > Build and Run a partir dos menus. Seu programa irá compilar e fazer o link. Em seguida, ele será instalado no iPhone Simulator, e do iPhone Simulator irá iniciar. Se você tentar isso, utilizando o projeto que acaba de criar usando o modelo Window-Based Application, você verá todo o processo, resultando em uma janela vazia branca sobre tela exibindo dentro do seu iPhone Simulator. Note que os programas só existem no seu Simulator (ou no iPhone), que não pode ser executado diretamente em seu Macintosh. Se quiser mais tarde re-executar um programa que você já tenha compilado, você pode fazê-lo em uma das três maneiras. Você pode simplesmente clicar no botão do programa, que deve agora aparecer no seu Simulator. Ou, você pode escolher Run > Run a partir de dentro Xcode. Finalmente, você pode escolher Build and Go no Xcode, que só compila se for necessário, em seguida, executa seu programa. E é isso. Com uma compreensão rudimentar do Xcode agora em mãos, você está pronto desenvolver seu primeiro programa.

Criando um primeiro projeto no XCODE: Olá, Mundo!

Como já observado, você deve iniciar qualquer projeto, executando File > New Project, escolher um modelo, e nomear o seu projeto. Para a nossa primeira amostra de projeto, foram selecionados o modelo Window-Based Application, e o nome alomundo. Antes de você começar a escrever o novo código, você precisa de uma compreensão básica do que já está lá, por isso vamos analisar o conteúdo dos três mais importantes arquivos que o nosso modelo Window-Based, que são: main.m, alomundoAppDelegate.h, e o alomundoAppDelegate.m.

Entendendo o  main.m

O primeiro arquivo criado pelo XCODE é main.m, que contém a sua função principal:

A criação desta rotina principal é automática, e você geralmente não deve perder  tempo com ele. No entanto, vale a pena entender como ele funciona. Ele Começa com uma diretiva #import, que é o equivalente do Objective-C ao #include do C#. Mais especificamente, você incluiu o UIKit framework, que é o mais importante framework no Objective-C.

O próximo a ser criado é o NSAutoreleasePool. Você deve se lembrar dele, pois foi mencionado em nossa discussão de gestão de memória no capítulo anterior. É o que dá suporte ao método autorelease da classe NSObject. Observe também que você libera o pool  depois que você executar o seu pedido principal da rotina, seguindo a regra de que, se você atribuir a memória para um objeto, você também deve liberá-lo.

A linha com o UIApplicationMain é o que cria a sua aplicação e executa o seu ciclo de evento. Os argumentos da função se parecem com isto:

Tal como acontece com o resto do arquivo main.m, você nunca deve ter de alterar esta código, mas devemos, no entanto, falar brevemente sobre os dois últimos argumentos embora eles geralmente serem definidos por padrão como nil (nulos) .

O principalClassName define a classe principal  da aplicação, por padrão é o UIApplication. Esta categoria tem uma série de ações e controle de eventos para o seu programa, tema que vamos voltar a falar em outros capítulos. O objeto UIApplication é criado como parte desta rotina inicial, mas note que nenhuma link com o objeto é provido. Se precisar acessá-lo (e você irá), você pode utilizar um método da classe UIApplication para fazê-lo:

Isso retornará o objeto da aplicação. Isto será normalmente enviado como parte de uma mensagem aninhada UIApplication para um método, como você verá em futuros capítulos.

Por enquanto, a aplicação faz duas coisas a se notar: ela chama o arquivo .xib padrão e ele interage com seu Application Delegate. O delegateClassName define a aplicação do objeto delegado. Como já se observou ali, este é o objeto que responde a algumas mensagens da aplicação, tal como foi definido pelo protocolo da classe UIApplicationDelegate. Entre outras coisas, a aplicação deve responder e delegar o ciclo de vida das mensagens, mais especificamente o applicationDidFinishLaunching: que controla o seu programa em termos de conteúdo, como iremos falar mais tarde. Nos moldes do Xcode, seus arquivos de classes delegates sempre terão o nome do projeto + appdelegate. Seu programa irá encontrá-los, graças a propriedade delegate que é construído no Interface Builder. Você pode mudar os argumentos enviados para UIApplicationMain e você pode adicionar ao arquivo main.m outros comandos, mas geralmente não vai querer. O padrão deve funcionar bem para todos os programas. Então, vamos sair do main.m e nos voltar para o arquivo onde qualquer programação realmente começa:  O application delegate.

Entendendo o application delegate

Como você já viu, o application delegate é responsável por responder a muitas das mensagens das aplicações. Você pode referenciar ao capítulo anterior, para uma lista de algumas das mais importantes ou ir guia de referência da Apple e fuçar UIApplicationDelegate para uma listagem completa. Mais especificamente, um application delegate deve fazer o seguinte:

• No momento do lançamento, é preciso criar um objeto Window e exibi-lo para o usuário.
• É preciso inicializar seus dados.
• É preciso responder ao pedido de “quit”.
• É preciso lidar com advertências de baixa memória.

Entre estes itens, é o primeiro que é de extrema importância para você agora. Seus arquivos de application delegate, alomundoAppDelegate.h e alomundoAppDelegate.m, sabem desta forma que o seu programa começou ..

O Arquivo Header

Agora, você está realmente usando classes, que é o tipo de codificação que compõe a grande maioria dos códigos Objective-C. vamos mostrar o conteúdo de seu primeiro arquivo de cabeçalho de classe, alomundoAppDelegate.h.

Novamente, não há nada para mudar daqui, mas queremos analisar o conteúdo, tanto para reiterar algumas das lições que aprendemos no capítulo anterior como para lhe dar uma boa base para um trabalho que vai fazer no futuro.  Primeiro, você verá uma linha interface (1) que herda suas delegações do NSObject e inclui uma promessa de seguir o protocolo UIApplicationDelegate.  Em seguida, você tem a declaração de uma variável de instância do objeto UIWindow (2).  Finalmente, você declara essa variável window como uma propriedade (3). Você notará que esta declaração,  inclui alguns dos atributos que nós já mencionamos anteriormente, que são nonatomic,  retain. Esta linha inclui também uma declaração IBOutlet, que diz que o objeto  foi realmente criado no Interface Builder. Iremos examinar este conceito de forma mais aprofundada no próximo capítulo, mas, por enquanto, você só precisa saber que você tem um objeto window já preparado para seu uso.  Embora você não possa modificar este arquivo header neste exemplo, você vai no futuro,  e você geralmente irá repetir os padrões que você vê aqui: criando mais  variáveis de instancia, incluindo IBOutlets, e definirá mais propriedades. Você também pode declarar cabeçalho de métodos neste arquivo, algo que este exemplo de cabeçalho não contém.

O Arquivo source code (Código fonte)

Vamos agora para o arquivo onde exibe código-fonte do application delegate, que é o alomundoAppDelegate.m, e é aqui que você vai  colocar o seu novo código.

O Código começa com a inclusão do arquivo de cabeçalho da classe (1) e um @implementation (2). Sua propriedade window (3), também recebe uma declaração @synthesize (vide capitulo 5). Mas é o conteúdo do método applicationDidFinishingLaunching (4) que  realmente interessa a você. Como você pode relembrar, essa é uma das mensagens de ciclo de vida do iPhone OS  que falamos nos capítulos anteriores. Sempre que uma aplicação do iPhone é totalmente  carregado na memória, vai enviar uma mensagem applicationDidFinishingLaunching: para  aplicação delegada, na execução desse método. Você vai notar há já existe um código para exibir a janela que será criada (5).

Para este projeto básico, você adicionará o seu novo código para que essa mesma rotina faça o objeto dizer “Olá, Mundo!”

Escrevendo o código

Fui otimista ao dizer como é fácil escrever códigos utilizando o SDK do iPhone em capítulos anteriores. Contudo, o programa  ”Olá, Mundo!” pode não ser tão fácil como um comando “print” em uma única declaração, mas é bastante simples, considerando que você está  lidando com um complexo ambiente de interface gráfica com janelas.  Como prometido, você escreverá tudo dentro do método applicationDidFinishingLaunching, como mostraremos:

Imaginando que este é o seu primeiro olhar num código real de Objective-C, vamos examinar tudo com certa profundidade.

Sobre a janela

O código começa enviando uma mensagem para o objeto window, dizendo para ele para definir o seu background para azul (1). Se você recordar da nossa discussão do arquivo header, dissemos que o Interface Builder foi quem criou a janela. O IBOutlet que foi definido no cabeçalho é o que permite fazer este tipo de manipulação.  Note que esta linha também faz uso de uma mensagem aninhada, o que havíamos prometido que aconteceria com uma certa freqüência. Aqui, você faz uma chamada para o objeto UIColor e solicita que  para ele envie a cor vermelha. Você, então,  passa isso para a sua janela.  Neste curso, vamos atingir um grande número de classes do UIKit sem explicar com muita  profundidade. Isso porque os objetos mais simples têm todas as interfaces padrões, a único complexidade  é, em particular as mensagens que eles aceitam. Se você se sentir como se fosse precisar de mais informações sobre uma classe, você deve olhar no guia de referência da Apple, disponível online em  developer.apple.com (ou no Xcode).

Sobre Frames

Você irá agora definir onde o seu texto será colocado. Você inicia o processo usando CGRectMake para definir um retângulo (2). Trabalharemos com Canvas da tela, o SDK utiliza um  grade com a origem (0,0) fixado na parte superior esquerda. Seu retângulo iniciará, portanto, 50 pixels à direita e 50 para baixo (50,50) a partir da origem. O resto dessa linha de código define o retângulo em 150 pixels de largura e 40 de altura, que é espaço suficiente para o seu texto.  Você vai usar este retângulo como um “Frame”, que é um dos métodos que você pode usar para definir uma visão da localização.

Sobre Labels

O label é uma simples classe que lhe permite escrever texto na tela. Como você poderia esperar, o seu label começa com a própria criação de um objeto label (3).  Note que ele segue o padrão de metodologia de criação de objetos aninhados que nós introduzimos nos capítulos anteriores. Primeiro você usa um objeto de classe para alocar o objeto, e então usamos um método de instância para inicializá-lo.  Depois de enviar uma série de mensagens para seu objeto, desta vez utilizando o ponto ( Oferecemos isso como uma variação da forma como você define o  janela da cor de fundo. Se preferir, você pode  utilizar o ponto window.backgroundColor lá, também. As duas maneiras de acessar propriedades são  totalmente equivalentes.  O mais importante dessas mensagens define o  texto do label. Você também pode definir um tamanho de fonte e algumas cores.  Você ainda pode dar ao texto uma atraente sombra preta, para demonstrar como é fácil fazer coisas legais  usando os objetos do iPhoneSO.  Cada objeto que você usar a partir de um Framework vai ter diversas propriedades, métodos e notificações  que você poderá tirar vantagem. O melhor lugar para procurar é  no guia de referências de classes.

Executando o Alô Mundo!

Para compilar e executar no Xcode, escolha Build > Build and Run a partir dos menus. Lembro que várias formas de se criar no XCODE e eu mostrei apenas como fazer no código, sem a utulização do Interface Buider para que você veja a quantidade de código que é inserido, sem o uso desta ferramenta. No próximo capítulo voce verá esta mesma aplicação sendo criada facilmente pelo IB sem digitar uma linha de código e veremos também outra aplicação mais complexa. Abraços.

Olá programadores. Neste post iremos aprender sobre criação de objetos, gerenciamento de memória, eventos, delegates e data sources. Isto visto pelo comportamento do iPhone OS.

Como você viu no capítulo anterior, o iPhoneOS tem uma complexa e profunda estrutura de classes. Duas das mais importantes são NSObject e UIResponder, que contêm muitos dos métodos e propriedades que você vai usar em toda a sua programação. Graças à herança, essas importantes funções (e outras) podem ser utilizadas por diversos objetos no iPhone OS.
Nós vamos cobrir alguns destes métodos fundamentais aqui para apresentar uma única referência para o seu uso, mas esteja certo que nós vamos falar deles novamente quando nos deparamos para pela primeira vez com esses métodos em futuro capítulos.

CRIAÇÃO DE OBJETOS

Já anteriormente falamos como definir classes, mas, como nós dissemos às vezes as especificidades de como instâncias de objetos são criados a partir de classes dependem da estrutura de seu framework. No iPhoneOS é o NSObject que define como a criação do objeto trabalha. Você tem que satisfazer algumas diferentes interfaces que são utilizadas para apoiar a criação do objeto, mas todos eles, em última instância, são definidos em dois passos que utilizam o método de classe alloc e a instância de método init. O método alloc aloca a memória para o seu objeto e, em seguida, retorna o próprio objeto. O método init então configura algumas variáveis iniciais do método. Eles ocorrem normalmente através de uma única, aninhada mensagem:

id novoObjeto = [[objetoDeClasse alloc] init];

O método Alloc da classe NSObject deve sempre fazer a coisa certa para você. Contudo, quando você escrever uma nova subclasse você quase sempre vai escrever um novo método init, porque é ali onde você define as variáveis que tornam a sua classe o que ela é. Abaixo, mostro uma configuração padrão para um init, que seria exibido como parte do seu @implementation

Este código mostra todas as exigências habituais de um método init. Primeiro, ele chama o seu método pai (1) para iniciar a sua classe habitual de inicialização. Em seguida, põe-se qualquer instância de variável que deva ser criada (2). Por fim, ele retorna o objeto, geralmente com “return self”(3).

Este formato de Init é apenas uma das muitas maneiras que você pode usar para criar objetos no iPhone OS.

O ARGUMENTO ALTERNATIVO

Às vezes você deseja enviar um argumento junto com um init. Você pode fazer isso com uma inicialização de função que você nomeia usando o formato initWithArgument:. Exceto o fato de que você está lhe enviando um argumento, funciona exatamente como o código do init anterior. Aqui está outro exemplo extraída de código real que veremos nos próximos capítulos:

[[UITextView alloc] initWithArgument: argumento];

Métodos de Inicialização com argumentos  permitem que você crie objetos atípicos, criados da maneira que você escolher. Eles são bastante comuns na UIKit (Classe de interface com o usuário). Um método de inicialização com um argumento que merece mencionar é o initWithCoder: é um método especial de inicialização que é chamado sempre que você criar um objeto com o Interface Builder, e, portanto, ele é importante se você deseja fazer configurações nestes objetos.

O MÉTODO FACTORY ALTERNATIVO

Um último tipo de init apoiada através do iPhone OS é o método factory. Este é criado através de uma mensagem que cuida tanto da alocação de memória quanto para a inicialização. Todos os métodos factory são nomeadas com o formato objecttypeWithArgument:. Aqui está outro exemplo real:

[UIButton buttonWithType:UIButtonTypeRoundedRect];

Os métodos da classe factory se fazem um pouco mais claras, mas eles também têm a vantagem de cuidar da gestão de memória para você, que é o tema da nossa próxima categoria principal dos  métodos do iPhoneOS.

RESUMO DE CRIAÇÃO DE OBJETOS

GERENCIAMENTO DE MEMÓRIA

Devido à limitações de potência, o iPhoneOS não suporta coleta (Garbage Collector – coletor de lixo). Isso significa que cada objeto que é criado deve finalmente ter a sua memória liberada na mão, pelo menos, se você não pretende introduzir um vazamento de memória em seu programa. A regra fundamental da gestão de memória no iPhoneOS é esta: se você alocar a memória de um objeto, você deve liberá-lo. Isto é feito através de uma mensagem de liberação(o que é mais uma vez, herdado do NSObject):

[objeto liberação];

Você enviará essa mensagem quando não utilizar mais seu objeto. Fazendo isso,  você fez o seu dever, como um bom programador. Note que eu disse que você só deve liberar a memória se você atribuíu a memória para ele. Se você olhar para trás para os métodos da classe factory que falámos no seção anterior, você verá que nós realmente não alocamos a memória para eles (porque não enviamos qualquer mensagem alloc), o que significa que não somos responsáveis por disponibilizá-la. Em vez disso, o objeto de classe que realmente fez a criação tem de limpar a sua memória. Como o sistema operacional sabe quando terminei de trabalhar com o objeto criado? Isso é feito através do maravilhoso autorelease.

O AUTORELEASE ALTERNATIVO

Se você é responsável pela criação de um objeto e que vai passá-la para fora para algumas outras classes de uso, você deve autorelease o objeto antes de enviá-la. Isto é feito com o método autorelease:

[objeto autorelease];

Em geral, você irá enviar a mensagem autorelease mesmo antes de devolver o objeto no final de um método. Quando um objeto sofre um autorelease, é supervisionado por uma especial  classe NSAutoreleasePool. O objeto é mantido vivo para o escôpo do  do método que o chamou e, em seguida, o NSAutoreleasePool o libera.

RETENDO E CONTANDO

Então como fazer, se quiser manter um objeto que tenha sido passado para você, e que  vai sofrer um autorelease? Nesse caso,  lhe enviamos uma mensagem retain (reter):

[objeto retain];

Quando você fizer isso, você está dizendo que você deseja ao objeto para ficar por perto, mas agora você irá se tornar responsável pela sua memória então: você deve enviar uma mensagem de release em algum ponto para manter o seu equilíbrio de memória.

Neste ponto, nós provavelmente devemos voltar e explicar a forma subjacente de que o iPhoneOS efectivamente gera a memória destes objetos. Ele o faz através da manutenção de uma contagem de objetos em uso. Por padrão, é definido como 1. Cada mensagem alloc e retain  incrementam o contador em 1, e cada mensagem de release reduz a contagem de 1. Quando a contagem cai para 0 (zero), a memória para o objeto é liberada. Portanto, toda a gestão de memória pode ser pensada como pares de mensagens. Se você equilíbrar cada alloc e retain com um release, o seu objeto será eventualmente liberado quando tiver terminado usá-lo.

RESUMO DOS MÉTODOS DE GERENCIAMENTO DE MEMÓRIA

EVENTO RESPONSE

Segue a última categoria de métodos que iremos analisar para o iPhoneOS é o evento response (resposta). Ao contrário da criação de objeto e gestão de memória, vamos apenas abordar esta questão rapidamente, porque muito melhor documentado em um próximo post. O tema é tão importante que queremos por agora oferecer uma visão geral rápida por enquanto.

Existem três formas principais, que podem aparecer em eventos do iPhone: através de chamadas de eventos simples (ou actions  – ações), através de delegações de eventos, ou através de notificação.

Apesar dos métodos de todos os nossos tópicos anteriores serem derivados da classe NSObject, o evento response do iPhone vem do objeto UIResponder, enquanto uma notificação provém do NSNotificationCenter.

Você não precisa se preocupar em como acessar o método response e suas propriedades. Como o UIResponder,  eles herdam da classe UIKit, mas o NSNotificationCenter exigirá acesso especial.

Este capitulo será atualizado ainda esta semana. Pois ainda falta explicar melhor isto.

E por enquanto é só.  No próximo capitulo vamos começar já com o XCODE. Abraços.

Olá… Neste artigo vamos conhecer um pouco do iPhoneOS seu principais recursos e principalmente suas limitações. Conhecer estas limitações é importantíssimo para evitar o eventual desligamento de sua aplicação pelo Apple App Killswitch (Espécie de guarda que desliga uma aplicação que esteja consumindo muitos recurso).

A ANATOMIA DO IPHONEOS

O Framework do iPhoneOs é dividido em quatro grandes camadas, como mostrado na figura. Cada uma destas camadas contém uma variedade de frameworks que você pode ter acesso ao escrever programas no iPhone SDK. Geralmente, você deve preferir uma camada de alto nível quando você estiver codificando (os indicados em direção ao topo do diagrama).

Cocoa Touch é o framework que você deve se tornar mais familiarizado. Contém o framework UIKit e é nele que passaremos mais de 90 % deste curso.  A framework UIKit inclui suporte a “Window”,  suporte a eventos e suporte a gerenciamento de interfaces de usuário, e permite que você crie texto e páginas de web. Ele ainda funciona como sua interface com o acelerômetro , a câmera, a biblioteca de fotos, e informações específicas de cada dispositivo.

Media é o lugar onde você pode ter acesso aos principais protocolos de áudio e vídeo embutido no iPhone. Existem quatro tecnologias gráficas presentes: OpenGL ES, EAGL (que liga
objetos OpenGL para a sua “window” nativa), quartzo (que é uma engine da Apple baseado em desenho vectorial), e o Core Animation (que também é construída sobre Quartz). Outros frameworks
dignos de nota incluem Core Audio, Open Audio Library, e Media Player.

Core Services oferece os frameworks utilizados em todas as aplicações. Muitos deles são dados  conexos, tais como o interno Address Book framework. Core Services inclui também a  critical Foundation framework, o que inclui as principais definições dos tipos de dados orientados a objeto da Apple, tais como as suas matrizes e conjuntos.

Core OS inclui o kernel-level software. Você pode acessar threading, arquivos, rede, I/O, e memória.

A HIERARQUIA DOS OBJETOS DO IPHONE

Dentro desses frameworks você será hábil para acessar a uma imensa riqueza das classes que estão dispostos em uma enorme hierarquia. Você verá muitas destas classes  utilizadas em todo este curso. Na Figura abaixo mostro muitas das classes que vamos usar ao longo dos vários artigos, organizados em hierarquia. Eles são apenas uma fração do que está disponível. Conforme mostrado na figura, os objetos que tem tem maior probabilidade de uso estão divididos em duas categorias gerais.

AS CLASSES NS

As classes NS provêm do Core Services Foundation framework (um Cocoa equivalente do Core Foundation framework), que contém um grande número de tipos de dados fundamentais e de outros objetos. Você deve usar as classes fundamentais do Cocoa como NSString e NSArray sempre que você puder. Isto porque eles tendem a se dar muito bem uns com os outros e com o framework UIKit, e portanto, é menos provável que você encontre erros bizarros. Apesar de não ser mostrado, NSNumber é outra classe que você deve usar sempre. Deve ser o seu principal objeto numérico quando você estiver fazendo qualquer tipo de trabalho complexo com números. Pode ser utilizada para reter muitos tipos de valores numéricos, flutuantes, inteiros e mais.  Os objetos que podem conter coleções de valores são NSArray (um array numérico) e NSDictionary (um array associativo). Somente estes insteressam mais nas classes NS.

AS CLASSES UI

A segunda categoria geral de classes contém as classes UI. Estes vêm do Cocoa Touch do framework do UIKit. Ela inclui todos os objetos gráficos que você usa, bem como todas as funcionalidades para o iPhone OS event model, muitos deles aparecem no UIResponder. Mas este é um outro tema que vamos voltar em breve.

WINDOWS E VIEWS

Como as classes IU demonstram, o iPhoneOS é profundamente enraizada na ideia de uma interface gráfica de usuário. Por isso, vamos terminar nossa introdução do iPhoneOS examinando algumas das principais abstrações gráfico embutidas no UIKit. Existem três abstrações principais: Windows, Views, e view controllers.  Um Window é algo que toma toda a tela do iPhone. Há apenas um deles para a sua aplicação, e é o recipiente para tudo o que a sua aplicação mostrar.  Um View é o conteúdo real mostrado na sua tela. Você pode ter vários deles, cada um abrangendo diferentes partes do Window (Janela)  ou fazendo coisas diferentes em tempos diferentes. Eles são todos derivados da classe UIView. No entanto, não basta pensar em um view como um recipiente vazio.

Atualmente, praticamente qualquer objeto que você usar a partir do UIKit será uma subclasse do UIView que apresenta uma grande quantidade de comportamentos herdados de si mesmo. Entre as grandes subclasses de UIView são UIControls, que lhe dará botões, cursores, e outros itens que os usuários podem manipular o seu programa com, e UIScrollableViews, que fornecerá aos usuários o acesso ao texto que não pode aparecer mais de uma vez. Um View controller faz o que seu nome sugere. Ela atua como o elemento controlador do modelo MVC e no processo de gerenciamento de telas cheias de texto, que é às vezes chamado por um view. Como tal, ele cuida de eventos e de actualização para o seu view.  Neste curso, dividimos os view controllers  em dois tipos.
View Controllers Básicos  são aqueles que apenas gerenciam telas de texto (como o tab bar controller), enquanto view controllers avançados são aqueles que permitem que um usuário se desloque entre as várias páginas de texto (tais como o navigation bar controller e o tab bar controller). A figura abaixo mostra como esses três tipos de objetos interrelacionem.

Windows, views, e view controllers são, em última análise, parte de uma visão hierarquia. Esta é uma árvore de objetos que começa com o Window na sua raiz. Um programa simples pode apenas ter um Window com um view nela. A maioria dos programas terá início com um Window, um view e um view controlller em que, talvez apoiados por view controllers adicionais, controlam views que deveraão ter os seus próprios subviews. Iremos descrever este conceito mais claramente nos próximos artigos, quando começarmos a olhar para a visualização básica de controladores. Até lá …

Olá! Neste capítulo vamos fechar o conteúdo sobre Objective-C para podermos ,no próximo, começar a falar do Sistema Operacional do Iphone, seus recursos e limitações. Aqui você aprenderá sobre “Properties”, “Categories” e “Protocols”.

PROPERTIES (PROPRIEDADES)

 
O que estudamos até agora deveria ser suficiente para que você possa compreender (e escrever) um simples código de Objective-C. Mas há outra grande característica em Objective-C, que merece ampla discussão por causa de sua sintaxe única: a propriedade.

O PROPÓSITO DAS PROPRIEDADES

Para que variáveis instanciadas sejam encapsuladas, normalmente você tem que escrever toneladas de métodos get’s e set’s quando se trabalha com OOP. Isso pode ficar tedioso, e você também deve ser cuidadoso com a consistência, para que você não tenha dezenas de diferentes sintaxes para seus “acessories” (Variáveis de acesso a dados) e “mutators” (Métodos modificadores).
Objective-C oferece uma solução para estes problemas: Você pode declarar uma instância de variável como uma propriedade. Ao fazer isso, você padroniza a variável de acesso e o método modificador de valor e cria getters e setters  automaticamente. O método de modificador  é chamado de “setVariable” e os de leitura  chamados com o nome escolhido para a variável de acesso.
Por exemplo, se voltarmos para classe das maçãs que falamos no nosso grande exemplo anterior, definimos a nossa variável  ”NSString * appleType” como uma propriedade, feito isso as seguintes declarações seriam automaticamente criadas:

(void)setAppleType: (NSString *) newValue;
(NSString *)appleType;

Você nunca  vai ver estas declarações, mas eles estarão lá.

CONFIGURANDO UMA PROPRIEDADE

Você declara uma instância de variável como uma propriedade usando a diretiva @property, como parte de sua declaração @interface. Abaixo segue um exemplo do estou falando:

O cabeçalho do arquivo mostra que qualquer propriedade deve começar com a declaração de uma instância
(1). A diretiva @property (2) , em seguida, repete essa declaração. Se desejar, você pode parar aqui. Você já implicitamente declarou seus acessadores, modificadores e métodos, ou você pode continuar e escrever os seus próprios métodos manualmente se assim quiser.
Objective-C também irá escrever estes métodos para você, bastando apenas pedir para ele! Isto é feito com a declaração @sintetize na diretiva @implementation (3). Isto criará métodos acessadores que lêem e alteram a variável da forma que você está acostumado. O método de inserção(set) é, por padrão o principal, mas você pode escolher um outro método utilizando propriedades e atributos, e que nós vamos falar conforme estudamos.

USANDO ACESSADORES

Se você não for fazer nada extravagante, você pode usar imediatamente em sua classe os acessadores, modificadores e métodos, conforme mostrado nos seguintes três exemplos:

NSString * choosenType = [AppleTree appleType];
[AppleTree setAppleType: @ "Washington Vermelha"];
[AppleTree setAppleType: myAppleType];

Além de lhe prover automaticamente acessadores e modificadores, “@properties” também lhe dá acesso a um pouco de limpesa sintática, que pode tornar a sua utilização, muito mais fácil.

Outra forma de notação

Esiste uma outra forma de se acessar propriedades de classes no Objective-C e que lembra muito o formato normal de linguagens de programação orientadas a objeto que estamos acustamos. Porém como a idéia aqui é aprender a sintaxe do Objective-C eu desaprovo a utilização desta notação. Mas para fim de conhecimento saiba que você pode acessar as propriedades declarados na diretiva @property com a utilização do ponto “.”).

A sintaxe abaixo é a converção para esta notação usando o ponto do nosso último exemplo:

 NSString *ChoosenType = AppleTree.appleType;
AppleTree.appleType = @”Washington Red”;
AppleTree.appleType = myAppleType;

Com isto em mãos você já está habil para escrever códigos simples. Existem outras diretivas de compilação para facilitar o desenvolvedor, mas acho melhor não aprendermos agora para que você digira melhor o que foi ensinado até aqui 

Muitas vezes a arroba (@) é usada para criar variáveis de certos tipos. Ela é mais frequentemente usada para criar uma variável do tipo  String (NSString *). Vimos isso em alguns dos nossos exemplos. Você apenas deve incluir o símbolo @, seguido pelo o valor da seqüência de caracteres que você quer definir:

NSString * mySample @ = “O que tem isto a ver com maçãs?”;

Ei tentarei no decorrer do curso, passar a maioria destas diretivas e gradativamente aumentar a complexidade dos códigos para o fácil aprendizado.

CATEGORIES E PROTOCOLS

Existem dois elementos finais no Objective-C, que acho importante, pelo menos, tocar comentar: Categories e Protocols. Vou definir o que fazem, mas não iremos mergulhar profundamente em seus detalhes. Para saber mais, consulte a documentação da Apple que está no link deste Blog.

Categories

Categories são usados se você quiser adicionar comportamento a uma classe sem herdar de outra (subclassing). Como sempre, você deve fazê-lo através da criação de um novo par de arquivos de código que contenham @interface e o @implementation. Desta vez você não precisa mais se preocupar com o nome da classe pai (Super), mas deve incluir um nome de categoria entre parênteses, como se segue:

@interface AppleTree (MyAppleChanges)
@implementation AppleTree (MyAppleChanges)

Como resultado, os métodos e as variáveis categorizados que você descreveria para a classe serão adicionados ao núcleo da classe de definição do seu programa.
Nós não usaremos categories neste curso.

Protocols

Um protocolo é efetivamente um comportamento que não é vinculado a uma classe. Nele se declara um conjunto de métodos, listando seus argumentos e os seus retornos. As Classes podem, em seguida, afirmar que eles estão usando este protocolo na sua própria declaração @interface.

Por exemplo, se tivéssemos um protocolo Crescer que é utilizada por plantas e animais parecidos, poderíamos definir a sua utilização como segue:

@interface AppleTree: UrTree <Crescer>

A classe AppleTree seria assim capaz de responder a todos os métodos definidos no protocolo Crescer.
Veremos alguns exemplos de Protocols no decorrer do curso.

Abaixo um resumo de tudo que aprendemos até agora sobre a sintaxe do Objective-C:

Bom acho que o fundamental já foi explicado, e o que faremos no próximo capítulo será aprender sobre o S.O. do iPhone. Tentarei resumir tudo num único capítulo para podermos em seguida meter a mão na massa e fazermos nosso primeiro programa no iPhone.

Até lá…