[Objc keep_it: simple];
Objective-C é
apenas um
conjunto de adições à linguagem C. Ela
dá
ao C suporte à construções orientadas
a objetos
como as da Smalltalk.
[Objc keep_it: elegant];
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!
[Objc keep_it: fast];
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.
gcc arquivos.m -o nome_do_programa -l objc
//
// 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;
}
@interface NovaClasse: SuperClasse
{
Declaração_de_variáveis;
}
Declaração_de_métodos;
@end
@interface NovaClasse
Definição_de_métodos;
@end
gcc meuGato.m -o meuGato -l objc
Miaau!
//
// 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;
}
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;
Gato *meuGato = [[Gato alloc] init];
Miaau!
Miaau!
meuGato pesa: 4.200000 kg
meuGato2 pesa: 4.900000 kg
-(tipo) nome: (tipo) variável nome: (tipo) variável;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.
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];
<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;
}
//
// 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
//
// 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
//
// 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;
}
gcc arquivo1.m arquivo2.m main.m -o nome_do_programa -l objc
gcc Gato.m main.m -o gato -l objc
Miaau!
Miaau!
Miaau!
meuGato pesa: 4.200000 kg
meuGato2 pesa: 4.900000 kg
meuGatoFilho pesa: 4.550000 kg
//
// 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
//
// 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
//
// 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
//
// 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
//
// 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
//
// 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
//
// 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;
}
//
// 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
//
// 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
//
// 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
//
// 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
[meuGato setEstado_Da_Pupila: 1];
[meuGato printEstado_Da_Pupila];
-(id) free
{
[AOlho free];
return [super free];
}
-(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;
}