O documento é uma introdução ao desenvolvimento de aplicativos para iOS, focando na linguagem Objective-C e no uso do iOS SDK. Ele abrange conceitos fundamentais como tipagem dinâmica, gerenciamento de memória, mensagens de objetos, definições de classes, herança, protocolos e propriedades. Além disso, apresenta a sintaxe da linguagem, manipuladores de exceções e a criação e inicialização de instâncias de classes.

1. Desenvolvimento de
aplicativos mobile para iOS
Aula 1 - Introdução à linguagem Objective-C e ao iOS SDK

2. Objective-C
https://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html#//
apple_ref/doc/uid/TP30001163

3. Extensão de ANSI C
• Convenção sintática para definição de classes
• Convenção para métodos de classe e instância
• Sintaxe para chamada de método (mensagem)
• Sintaxe para declaração de propriedades
• Convenção para tipagem estática e dinâmica
• Blocos - segmentos de código encapsulados
• Extensões da linguagem como protocolos e
categorias

4. Vantagens
• Tipagem dinâmica detemina classe em
tempo de execução.
• Ligação dinâmica determina o método a ser
chamado em tempo de execução.
• Carregamento dinâmico permite adicionar
módulos de código em tempo de execução.

5. Runtime System
Adiar decisões de compile time e
link time para runtime

6. Objetos
Um objeto associa dados com operações
que podem ser usadas para afetar os dados

7. id
• Objetos são um tipo de dados distinto: id
typedef struct objc_object {
Class isa;
} *id;

8. Dynamic Typing
Objetos são tipados dinamicamente
em tempo de execução.
id myObject;
É possível também informar ao compilador a
classe do objeto estaticamente informando a
classe no código fonte.
Rectangle* myObject;

9. Memory Management
• Automatic Reference Counting
(ARC) => iOS 5+
• Manual Reference Counting (MRC)
• Garbage Collection (not iOS)

10. Object Messaging
• Para fazer alguma coisa com um objeto,
você envia uma mensagem para ele
solicitando para executar um método.
[receiver message];
[myRectangle display];
[myRectangle setWidth:2.0];
[myRectangle setOriginX: 30.0 y: 50.0];
[receiver makeGroup:group, memberOne, memberTwo,
memberThree];
[myRectangle setPrimaryColor:[otherRect primaryColor]];

11. Messages to nil
• Enviar uma mensagem para um objeto nil
não tem nenhum efeito em tempo de
execução.
id anObjectMaybeNil = nil;
// this is valid
if ([anObjectMaybeNil methodThatReturnsADouble]
== 0.0)
{
// implementation continues...
}

12. Dynamic Binding
• Ao enviar uma mensagem à um objeto, o
método que será chamado é determinado
em tempo de execução.

13. Dot sintax
• Notação usando ponto (.) como alternativa
aos colchetes ([]) para invocar métodos de
acesso à propriedades.
myInstance.value = 10; [myInstance setValue:10];
self.age = 10; [self setAge:10];
x = person.address.street.name; x = [[[person address] street]
name];

14. Classes
• A definição de classe é um protótipo para
um tipo de objeto;
• O compilador cria um único objeto para
cada classe que sabe como criar outros
objetos (factory object)
• Este objeto constrói instâncias da classe.

15. Herança
NSObject
Graphic
Text Text
Shape
Line Rectangle

16. NSObject
• É uma classe raiz e não tem uma
superclasse.
• Define um framework básico para objetos
Objective-C e interação entre eles.

17. Herdando variáveis de
instância e métodos
• Quando um objeto de classe cria uma nova
instância, o novo objeto contém as variáveis
de instância e métodos definidos pela
classe assim como de suas superclasses.

18. Sobrescrevendo
métodos
• Envio de mensagens para self e super
para referenciar respectivamente métodos
da classe atual e das superclasses.

19. Classes Abstratas
• Objective-C não tem sintaxe para criação
de classes ou métodos abstratos.

20. Static Typing
• Você pode usar o nome da classe no lugar
de id para designar o tipo do objeto
Rectangle* myRectangle;

21. Type Introspection
• Instâncias podem consultar seu tipo em
tempo de execução:
if ( [anObject isMemberOfClass:someClass] )
...
if ( [anObject isKindOfClass:someClass] )
...

22. Class Objects
• O objeto da classe contêm:
• Nome da classe e sua superclasse
• Modelo das variáveis de instância
• Declaração dos métodos seu retorno e
seus argumentos
• Implementação dos métodos

23. Class Objects
• Todos os objetos de classe são do tipo
Class
Class aClass = [anObject class];
Class rectClass = [Rectangle class];

24. Criando instâncias
• A principal função do objeto da classe é
criar instâncias
Rectangle* myRectangle =
[[Rectangle alloc] init];
Rectangle* myRectangle =
[[Rectangle alloc]
initWithSize:CGSize(800, 600)];

25. Variáveis
• Para todas as instâncias da classe acessarem
uma variável, você deve defini-la
externamente.
static MyClass *MCLSSharedInstance;
@implementation MyClass
+ (MyClass *)sharedInstance
{
// check for existence of shared instance
return MCLSSharedInstance;
}

26. Inicializando objetos de
classe
• O método initialize é chamado antes da
criação da primeira instância da classe.
+ (void)initialize
{
if (self == [ThisClass class]) {
// Perform initialization here.
...
}
}

27. Definindo uma Classe
• Em Objective-C classes são definidas em
duas partes:
• Uma interface que declara os métodos
e propriedades;
• Uma implementação que contém o
código que implementa seus métodos.

28. Arquivos de código-
fonte
Extensão Tipo
Header files da definição de classes,
.h
tipos, funções e constantes.
Source files da implementação em
.m
Objective-C ou C
Source files da imeplementação em C++
.mm
além de Objective-C e C

29. Class Interface
• A declaração da interface da classe inicia
com a diretiva @interface e termina
com a diretiva @end
@interface ClassName : ItsSuperclass
// Method and property declarations.
@end

30. Instance methods
• Marcado com um sinal menos (-), o tipo de
retorno é opcional (usado id caso não
informado), parâmetros são separados por
dois pontos (:)
- (void)display;
- (float)radius;
- (void)setRadius:(float)aRadius;
- (void)setWidth:(float)width
height:(float)height;
- makeGroup:group, ...;

31. Class methods
• Segue a mesma convenção dos métodos de
instância, mas são marcadas com o sinal
mais (+)
+ (MyClass*)sharedInstance;
+ (MyClass*)objectWithWidth:(float)width
height:(float)height;

32. Variáveis de instância
@interface ClassName : ItsSuperclass
{
// Instance variable declarations.
float quantity;
Rectangle* rect;
}
// Method and property declarations.
@end

33. Importando a interface
• O arquivo de interface pode ser importado
em qualquer outro arquivo fonte.
#import "Rectangle.h"

34. Referindo-se à outras
classes
• Quando uma classe ainda não foi definida
mas precisa ser referenciada você pode
mencioná-la com a diretiva @class
@class Rectangle, Circle;

35. Class Implementation
• Começa com a diretiva
@implementation e termina com a
diretiva @end
@implementation ClassName
{
// Instance variable declarations.
}
// Method definitions.
@end

36. Using super
• O método init é pensado para funcionar
desta forma:
- (id)init {
self = [super init];
if (self) {
...
}
return self;
}

37. Protocolos
• Protocolos definem métodos que podem
ser implementados por qualquer classe. São
úteis para:
• Declarar métodos que espera que outra
classe implementa;
• Declarar uma interface escondendo sua
classe;
• Capturar similaridades sem relação
hierárquica

38. Protocolos Formais
• Usando a diretiva @protocol
@protocol ProtocolName
// method declarations
@end
@protocol MyProtocol
- (void)requiredMethod;
@optional
- (void)anOptionalMethod;
- (void)anotherOptionalMethod;
@required
- (void)anotherRequiredMethod;
@end

39. Protocolos Informais
• Agrupando métodos em uma declaração de
categoria
@interface NSObject ( MyXMLSupport )
- initFromXMLRepresentation:(NSXMLElement
*)XMLElement;
- (NSXMLElement *)XMLRepresentation;
@end

40. Implementando um
Protocolo
• Uma classe diz que adota um protocolo
formal indicando os protocolos entre
símbolos maior e menor (<>)
@interface ClassName : ItsSuperclass <
protocol list >
@interface ClassName ( CategoryName ) <
protocol list >
@interface Formatter : NSObject < Formatting,
Prettifying >

41. Conformidade com um
protocolo
• É possível verificar se um objeto está em
conformidade com um protocolo
if (![receiver
conformsToProtocol:@protocol(MyXMLSupport)]) {
// Object does not conform to MyXMLSupport
protocol
// If you are expecting receiver to
implement methods declared in the MyXMLSupport
protocol, this is probably an error
}

42. Type Checking
• Em uma declaração de tipo, os protocolos
são listados entre símbolos maior e menor
(<>)
- (id <Formatting>)formattingService;
Formatter<Formatting> *anObject;
id <MyXMLSupport> anObject;

43. Propriedades
• Tipicamente métodos de acesso à
propriedades do objeto são um par de
getters e setters. Propriedades oferecem:
• Uma especificação explícita de como os
métodos de acesso se comportam;
• O compilador pode criar esses métodos;
• Propriedades são identificadas
sintaticamente, o compilador dectecta
caso elas não existam;

44. Declaração de
propriedades
• Usando a diretiva @property
@property (attributes) type name;
@interface MyClass : NSObject
@property float value;
@end
// É equivalente à:
- (float)value;
- (void)setValue:(float)newValue;

45. Atributos
• Accessor methods names:
• getter=getterName, setter=setterName
• Writability
• readwrite, readonly
• Setter semantics
• strong, weak (ARC)
• copy, assign, retain (MRC)

46. Atributos
• Atomicity
• nonatomic, atomic (default)
• Markup and Deprecation
• __attribute__
• IBOutlet

47. Implementação da
propriedade
• Usar @synthesize ou @dynamic no
bloco @implementation
@interface MyClass : NSObject
@property(copy, readwrite) NSString *value;
@end
@implementation MyClass
@synthesize value = _value;
@end

48. Categorias e extensões
• Uma categoria permite adicionar métodos
à classes existentes.
#import "ClassName.h"
@interface ClassName ( CategoryName )
// method declarations
@end

49. Fast Enumeration
• Sintaxe para enumerar o conteúdo de
coleções
for ( Type newVariable in expression )
{ statements }
NSArray *array = [NSArray arrayWithObjects:
@"one", @"two", @"three", @"four",
nil];
for (NSString *element in array) {
NSLog(@"element: %@", element);
}

50. Selectors
• Em Objective-C selectors tem dois
sentidos:
• Pode ser usado para simplesmente
referenciar um método;
• Pode ser um identificador único que
substitui o nome após a compilação;

51. Métodos e selectors
SEL setWidthHeight;
setWidthHeight =
@selector(setWidth:height:);
setWidthHeight =
NSSelectorFromString(aBuffer);
NSString *method;
method =
NSStringFromSelector(setWidthHeight);

52. Variável para a chamada
do método
[friend
performSelector:@selector(gossipAbout:)
withObject:aNeighbor];
// É equivalente à:
[friend gossipAbout:aNeighbor];
id helper = getTheReceiver();
SEL request = getTheSelector();
[helper performSelector:request];

53. Evitando erros
if ( [anObject
respondsToSelector:@selector(setOrigin::)]
)
[anObject setOrigin:0.0 :0.0];
else
fprintf(stderr, "%s can’t be placed
n", [NSStringFromClass([anObject class])
UTF8String]);

54. Exception Handling
• Exceções em Objective-C suportam quatro
diretivas do compilador: @try, @catch,
@throw, @finally

55. Tratando exceções
Cup *cup = [[Cup alloc] init];
@try {
[cup fill];
}
@catch (NSException *exception) {
NSLog(@"main: Caught %@: %@", [exception
name], [exception reason]);
}
@catch (id ue) {
// ...
}
@finally {
[cup release];
}

56. Lançando exceções
NSException *exception = [NSException
exceptionWithName: @"HotTeaException"
reason: @"The tea is too hot"
userInfo: nil];
@throw exception;

57. DOJO!

58. DOJO!
Tic Tac Troll