Una breve introduzione su Objective-C: le sue caratteristiche principali

1. Intro

2. AGENDA
• Il linguaggio
• Xcode
• Classi e Oggetti
• Creare oggetti
• Proprietà degli oggetti
• Gestione (base) della memoria
• Init e dealloc

3. IL LINGUAGGIO (1)
Objective-C è il principale linguaggio di programmazione
che si utilizza per creare applicazioni per OSX.
E' la base da apprendere per utilizzare le librerie
(framework) che Apple mette a disposizione e che
consentono lo sviluppo di applicazioni su:
• OSX
• iPhone
• iPodTouch

4. IL LINGUAGGIO (2)
E' un linguaggio di programmazione ad oggetti
(paradigma OOP) con caratteristiche che lo rendono
simile sia a linguaggi come Java e C++.
Lasceremo (quasi) da parte la teoria della OOP e ci
soffermeremo più sul lato "pratico". Lo scopo infatti è
quello di dare degli strumento immediati per lo sviluppo.

5. XCODE (1)
Per "tradurre" il nostro programma in un linguaggio
comprensibile al computer abbiamo bisogno di un
compilatore. Il suo utilizzo avviene principalmente
attraverso due modi:
1) Invocazione manuale della compilazione (es. tramite
terminale)
2) Utilizzo di un ambiente di sviluppo integrato (IDE): nel
nostro caso Xcode

6. XCODE (2)
Xcode è quindi l'IDE di riferimento per lo sviluppo su
OSX. Utilizzeremo questo strumento perché:
• E' di facile utilizzo
• Le principali azioni sono a portata di click
• Ci avverte di eventuali errori presenti nel codice
• Mette a disposizione un elenco di template adatti al
tipo di applicazioni che andremo a sviluppare

7. XCODE (3)
http://developer.apple.com/technology/Xcode.html

8. CLASSI E OGGETTI (1)
Cosa sono?
"Think of an object as a fancy variable; it stores data, but
you can "make requests" to that object, asking it to do
operation on itself."
Bruce Eckel, Thinking in Java
Sono un'astrazione che ci permette di mappare oggetti
reali (o immaginari) in oggetti software. Così come nel
mondo reale, anche in OOP tutto è un oggetto... o quasi!

9. CLASSI E OGGETTI (2)
I nostri programmi quindi saranno un insieme di oggetti
che dialogano tra loro inviandosi messaggi e ricevendo
risposte.
Ogni oggetto appartiene ad una classe...

10. CLASSI E OGGETTI (3)
Una breve, ma importante distinzione:
• Classe: è una descrizione astratta, un prototipo, che
definisce il comportamento di un oggetto.
• Oggetto: è un'entità, appartenente ad una classe, con
un proprio stato e comportamento.

11. CLASSI E OGGETTI (4)
Durante lo sviluppo di un programma quindi, saremo soliti
definire una classe ed istanziare uno o più oggetti relativi
ad essa.
classe
oggetti

12. CREARE OGGETTI (1)
In Objective-C per definire un oggetto, quindi la classe cui
esso appartiene, abbiamo bisogno di due file:
• uno (.h) che definisce l'interfaccia della classe
• l'altro (.m) che ne definisce l'implementazione
L'interfaccia descrive le azioni (i metodi) della classe e
nasconde l'implementazione che definisce come i metodi
vengono realmente eseguiti.
Gli oggetti comunicano tramite le loro interfacce!

13. CREARE OGGETTI (2)
Definizione di un'interfaccia (MyClass.h)
@interface MyClass : NSObject {
dichiarazione di interfaccia classe di appartenenza
nome della classe - int variabile; variabili di classe
} metodi (azioni) esposti
- (void)eseguiMetodo;
@end

14. CREARE OGGETTI (3)
L'implementazione (MyClass.m)
#import "MyClass.h" interfaccia da implementare
@implementation MyClass
implementazione della classe
- (void)eseguiMetodo {
// esegui qualcosa...
implementazione dei metodi
}
@end

15. CREARE OGGETTI (4)
Struttura di un metodo:
- (void) eseguiMetodo;
tipologia di metodo tipo di ritorno nome del metodo
Un metodo può avere uno o più argomenti:
- (int) sommaNumero:(int)arg1 conNumero:(int)arg2;
tipo argomento nome argomento

16. PROPRIETA' (1)
Per permettere che le proprietà (variabili) di una classe
possano essere lette e/o modificate da chi la utilizza,
dobbiamo fornire dei metodi specifici (getter/setter).
Objective-C può generare automaticamente questi
metodi attraverso l'utilizzo delle keyword @properties e
@synthesize.

17. PROPRIETA' (2)
Nell'interfaccia dichiariamo per quali variabili vogliamo
creare i getter/setter
@interface MyClass : NSObject {
- int variabile;
}
@properties (retain) int variabile;
- (void)eseguiMetodo;
@end

18. PROPRIETA' (3)
Nell'implementazione esplicitiamo la creazione
automatica dei metodi.
#import "MyClass.h"
@implementation MyClass
@synthesize variabile;
- (void)eseguiMetodo {
// esegui qualcosa...
}
@end

19. GESTIONE MEMORIA (1)
La creazione di un oggetto implica l'occupazione di
memoria che successivamente dovrà essere liberata.
Possiamo riassumere il ciclo di vita di un oggetto nel
seguente modo:
alloc init use dealloc

20. GESTIONE MEMORIA (2)
• alloc: viene allocata (predisposta) la memoria necessaria
ad ospitare l'oggetto.
• init: viene inizializzato l'oggetto invocando il suo
costruttore, l'oggetto "prende vita".
• use: utilizzo dell'oggetto.
• dealloc: rimozione dalla memoria.

21. GESTIONE MEMORIA (3)
La gestione del ciclo di vita di un oggetto, si basa
sull'utilizzo di un "contatore" che tiene traccia di quanti
oggetti (esterni) hanno un riferimento ad esso.
Ogni volta che si crea un riferimento ad un oggetto il suo
contatore si incrementa, quando viene rimosso si
decrementa. Se il contatore raggiunge lo zero l'oggetto
viene rimosso dalla memoria.
Questo meccanismo è noto come retain/release

22. GESTIONE MEMORIA (4)
retain = 0
+1 MyClass *foo = [[MyClass alloc] init];
retain = 1 ...
time
-1 [foo release];
retain = 0
dealloc

23. GESTIONE MEMORIA (5)
retain = 0
+1 MyClass *foo = [[MyClass alloc] init];
retain = 1
[foo retain];
time
+1
retain = 2
-1 [foo release];
retain = 1
-1 [foo release];
retain = 0

24. GESTIONE MEMORIA (6)
E' importante ricordare che ad ogni retain (necessità di
conservare un riferimento ad un oggetto) deve
corrispondere un release (rilascio dell'oggetto).
L'inizializzazione di un oggetto corrisponde ad un retain.
Se non si segue questa regola si può avere un problema
detto di "memory leak": spazio di memoria utilizzato ma
che non possiamo liberare.

25. INIT E DEALLOC (1)
La creazione di un oggetto avviene attraverso
l'invocazione di un particolare metodo chiamato
costruttore. Non è necessario implementare questo
metodo in quanto ogni oggetto ha un costruttore di
default definito implicitamente.
MyClass *foo = [[MyClass alloc] init];
costruttore di default

26. INIT E DEALLOC (2)
Possiamo, però, avere la necessità di eseguire determinate
azioni al momento della creazione di un oggetto. In
questo caso possiamo ridefinire il metodo init (override
di init) adattandolo alle nostre esigenze.
@implementation MyClass
- (id)init {
if(self = [super init]) {
variabile = 1;// valorizzo la var
}
return self;
}

27. INIT E DEALLOC (3)
Analogamente al costruttore, possiamo ridefinire le azioni
al termine del ciclo di vita di un oggetto facendo
l'override del metodo dealloc.
@implementation MyClass
- (void)dealloc {
NSLog(@"Override di dealloc...bye!");
[super dealloc];
}

28. alla prossima...