Guida Objective-C in Italiano - Le Basi

Questo post è una traduzione in italiano della Guida all'Objective C, presente sul sito developer.apple.com a questo link. L'Objective C è il linguaggio di programmazione per creare applicazioni per iPhone. Questo articolo può interessare a tutti gli sviluppatori che vogliono imparare le basi di questo linguaggio che è il fondamento per programmare nuove applicazioni per Mac Os X, iPhone ed iPad.

In questo primo articolo saranno descritti alcuni dei concetti base della programmazione Object Oriented di questo linguaggio, quali appunto gli oggetti, il dynamic typing, la gestione della memoria, i messaggi, il polimorfismo, il dynamic binding, e la sintassi punto. Nel prossimo articolo di questa serie, verranno trattate le Classi e i concetti legati ad esse.

---

Guida Objective-C

Come dice il nome, i programmi OO (Object Oriented) sono orientati agli oggetti. Un oggetto associa dei dati con delle particolari operazioni che possono usare o modificare questi dati. Obj-C fornisce un tipo di dati per identificare le variabili senza specificarne una particolare classe di oggetti, questo permette la scrittura dinamica. In un programma puoi tipicamente assicurare che disponi di oggetti che non servono più.

Object Basics

Le operazioni di un oggetto sono i metodi; i suoi dati sono le variabili di istanza. Un oggetto essenzialmente include una struttura dati e un gruppo di procedure.
Ad esempio, se stai scrivendo un programma di disegno che permette a un utente di creare immagini composte da linee, cerchi, rettangoli, testi, immagini mappate, ecc... potresti creare una classe per ogni tipo di forma di base che un utente può manipolare. Un oggetto Rettangolo che ha come variabili di istanza delle variabili che identificano la posizione del rettangolo nel disegno, insieme alla base e altezza. Altre variabili di istanza potrebbero definire il colore del rettangolo, se è pieno o vuoto, e un line pattern che può essere usato per mostrare il rettangolo. Una classe Rettangolo dovrebbe avere metodi per settare la posizione di un'istanza, la dimensione, il colore, il riempimento e line pattern insieme ad un metodo che fa mostrare l'istanza stessa (display).
In Objective-C, una variabile di istanza di un oggetto è interna all'oggetto e vi si può accedere solo tramite i metodi dell'oggetto.
Un oggetto vede solo i metodi progettati per lui, quindi non può per errore eseguire dei metodi di altri tipi di oggetti. Un oggetto incapsula nascondendo all'esterno sia le sue variabili di istanza, sia le implementazioni dei suoi metodi.

Id

In Objective-C, gli identificatori di oggetti sono un distinto data type: id.
Questo è il tipo generale per ogni razza di oggetto, senza tener conto della classe. id è definito come un puntatore a una struttura dati di un oggetto:

typedef struct objc_object {

Class isa;

} *id;

Tutti gli oggetti quindi hanno una variabile isa che gli dice di quale classe sono un'istanza.
Terminologia: Dato che il tipo Class è definito come un puntatore:

typedef struct objc_class *Class;

la variabile isa si riferisce spesso al “puntatore isa”.
Come una funzione C o un array, un oggetto è identificato dal suo indirizzo. Tutti gli oggetti, ad eccezione delle loro variabili di istanza o metodi, sono di tipo id.

id anObject;

Per i costrutti OO dell' Objective-C, come i valori di ritorno dei metodi, id sostituisce int come tipo di dati di default.
La parola chiave nil è definita come un oggetto nullo, un id con valore 0. id, nil, e gli altri tipi di base dell' Objective-C sono definiti nell'header file objc/objc.h.

Dynamic Typing

(Wiki: Un linguaggio di programmazione è dinamicamente tipato, quando la maggioranza dei suoi controlli dei tipi è eseguita a tempo di esecuzione, invece che a tempo di compilazione.)
Il tipo id è completamente non restrittivo. da solo non rende informazioni su un oggetto, eccetto che esso è un oggetto. Ma gli oggetti non sono tutti uguali. Un Rettangolo non avrà gli stessi metodi o variabili di istanza di un oggetto che rappresenta un'immagine mappata. A un certo punto, un programma necessita di più informazioni specifiche riguardo a ciò che l'oggetto contiene, quali sono le sue variabili di istanza, quali metodi può eseguire ecc... Dato che il tipo id non può fornire queste informazioni al compilatore, ogni oggetto deve poterle fornire a tempo di esecuzione.
La variabile di istanza isa identifica la classe dell'oggetto. Ogni oggetto Rettangolo deve poter dire al sistema di runtime che è un Rettangolo. Ogni Cerchio può dire che è un Cerchio. Oggetti con lo stesso comportamento (metodi) e gli stessi tipi di dati (variabili di istanza) sono membri della stessa classe.
Gli oggetti quindi sono dinamicamente tipati a runtime. Ogni volta che serve, il sistema di runtime può trovare l'esatta classe a cui un oggetto appartiene, semplicemente chiedendo all'oggetto. Dynamic typing in Objective-C serve come fondamento per il dynamic binding, di cui parleremo in seguito.
La variabile isa abilita anche gli oggetti ad eseguire introspection, per scoprire informazioni su se stessi (o altri oggetti). Il compilatore registra informazioni sulle definizioni di classi, in strutture dati per farle usare al sistema di runtime. Le funzioni del sistema di runtime usano isa, per scoprire queste informazioni a runtime. Usando il runtime system, puoi, ad esempio, determinare se un oggetto implementa o meno un particolare metodo, o scoprire il nome della sua superclasse.
È anche possibile dare al compilatore informazioni riguardo la classe di ogni oggetto tipandolo staticamente nel codice sorgente usando il nome di classe. le Classi sono dei particolari tipi di oggetti, e il nome classe può servire come un nome di tipo.

Gestione Memoria

In un programma Objective-C, è importante assicurare che gli oggetti siano deallocati quando non servono più, altrimenti l'impronta nella memoria dell'applicazione diventa più grande del necessario. è anche importante assicurare che non si deallochino oggetti che devono essere usati ancora.
Objective-C offre due ambienti per la gestione della memoria che permettono ai seguenti obbiettivi di incontrarsi:

• Reference counting: dove sei ultimamente responsabile nel determinare il tempo di vita degli oggetti.
• Garbage collection: dove passi la responsabilità nel determinare il tempo di vita degli oggetti a un collector automatico.

Garbage collection sarà descritta in seguito.

Object Messaging

Questa sezione spiega la sintassi dell'invio dei messaggi, incluso come nidificare espressioni dei messaggi.

Sintassi Messaggi

Per far fare qualcosa ad un oggetto, gli invii un messaggio dicendogli di applicare un metodo. In Objective-C, message expressions sono racchiusi tra parentesi quadre:

[receiver message]

Il receiver è un oggetto, e il messaggio dice cosa fare. nel codice sorgente, il messaggio è il nome del metodo e gli eventuali parametri che gli vengono passati. Quando un messaggio è inviato, il sistema di runtime seleziona il metodo appropriato dal repertorio del receiver e lo invoca.
Ad esempio: questo mesaggio dice all'oggetto myRectangle di eseguire il suo metodo display, che causa la visualizzazione del rettangolo:

[myRectangle display];

Il messaggio è seguito da un “;” come è normale per ogni linea di codice C. Il nome del metodo in un messaggio serve a "selezionare" un'implementazione di metodo. Per questo motivo, ci si riferisce spesso ai nomi dei metodi come dei selectors. I metodi possono anche prendere parametri, o argomenti Un messaggio con un singolo argomento è scritto con i due punti (:) dopo il nome del selettore, e con l'argomento a seguire a destra dei due punti. Questo costrutto è chiamato parolachiave; una keyword finisce con i duepunti, e un artomento che li segue, come mostrato in questo esempio:

[myRectangle setWidth:20.0];

Un nome di selettore include tutte le keywords, inclusi i due punti, ma non include nient'altro, come tipi di ritorno o tipi di parametri. Il messaggo immaginario di sotto dice all'oggetto myRectangle di impostare la sua origine alle coordinate (30.0, 50.0):

[myRectangle setOrigin:30.0 :50.0]; // This is a bad example of multiple arguments

Dato che i due punti sono parte del nome del metodo, il nome del metodo è chiamato setOrigin::. Ha due due punti, perchè prende due argomenti. Questo particolare metodo non si interfoglia con il nome del metodo con gli argomenti e, quindi, Il secondo argomento è effettivamente non etichettato ed è difficile determinare il tipo di scopo degli argomenti del metodo. Invece, nomi dei metodi dovrebbero interforgliare i nomi con gli argomenti in modo tale che il nome del metodo descriva naturalmente gli argomenti passati al metodo. Ad esempio, la classe Rettangolo potrebbe invece implementare un metodo setOriginX:y: che renda chiaro lo scopo dei due argomenti:

[myRectangle setOriginX: 30.0 y: 50.0]; // This is a good example of multiple arguments

Importante: Le sotto parti del nome del metodo non sono opzionali, nè il loro ordine può essere variato. Gli “Argomenti nominati” e i “keyword arguments”, spesso implicano che gli argomenti di un metodo possono variare a runtime, possono avere diversi valori di default, possono essere in ordine diverso, possono avere argomenti addizionali nominati. Questo Non è il caso dell'Objective-C. Una dichiarazione di metodo in Objective-C è semplicemente una funzione C che prepone due argomenti addizionali. Metodi che prendono un numero variabile di argomenti sono comunque possibili, anche se molto rari. Argomenti extra sono separati da virgole dopo la fine del nome del metodo. (Diversamente dai due punti, le virgole non sono considerati parte del nome.) Nel seguente esempio, al metodo immaginario makeGroup: è passato un argomento richiesto (group) e tre opzionali:

[receiver makeGroup:group, memberOne, memberTwo, memberThree];

Come le funzioni C standard, i metodi possono restituire valori. Il seguente esempio imposta le variabili isFilled a YES se myRectangle è disegnato come un rettangolo solido, o NO se è disegnato solo in forma outline.

BOOL isFilled;

isFilled = [myRectangle isFilled];

Nota che una variabile e un metodo possono avere lo stesso nome. Un espressione di messaggio può essere nidificata in un altra. Qui, il colore di un rettangolo è settato al colore di un altro:

[myRectangle setPrimaryColor:[otherRect primaryColor]];

Objective-C fornisce anche un operatore punto (.) che offre una sintassi compatta e conveniente per invocare un metodo accessorio di un oggetto.

Inviare messaggi a nil

In Objective-C, è valido inviare messaggi a nil— semplicemente non ha effetti a runtime. Ci sono diversi patterns in Cocoa che si avvantaggiano da questo fatto. Il valore restituito da un messaggio a nil può anche essere valido:
Se il metodo restituisce un oggetto, allora un messaggio inviato a nil restituisce 0 (nil), ad esempio:

Person *motherInLaw = [[aPerson spouse] mother];

Se aPerson’s spouse (sposo) è nil, allora mother è inviato a nil e il metodo restituisce nil.
Se il metodo restituisce un qualunque tipo puntatore, un qualunquenumero intero, di dimensioni inferiori o uguali a sizeof(void*), un float, un double, un long double, o un long long, allora un messaggio inviato a nil restituisce 0.
Se il metodo restituisce una struct, come definito da Mac OS X ABI Function Call Guide da essere ritornato in registri, allora un messaggio inviato a nil restituisce 0.0 per ogni campo nella struttura dati. Altri tipi di data struct non saranno riempiti con zero.
Se il metodo restituisce qualsiasi cosa tranne i tipi sopracitati, il valore restituito da un messaggio inviato a nil è indefinito. Il seguente frammento di codice illustra un uso valido dell'invio di un messaggio a nil:

id anObjectMaybeNil = nil;

// this is valid

if ([anObjectMaybeNil methodThatReturnsADouble] == 0.0)

{

// implementation continues...

}

Note: Il comportamento di inviare messaggi a nil è cambia leggermente con Mac OS X v10.5.
Su Mac OS X v10.4 e precedenti, un messaggio a nil è valido, fintanto che il messaggio restituisce un oggetto, qualsiasi tipo putatore, void, o qualsiasi intero di dimensioni inferiori o uguali a sizeof(void*); se lo fa, un messaggio inviato a nil restituisce nil. Se il messaggio inviato a nil restituisce qualunque cosa tranne i valori di tipi sopracitati, (ad esempio, se restituisce un tipo struct, un tipo in virgola mobile, o un vettore) il valore restituito è indefinito. Non dovresti affidarti ai valori restituiti da messaggi inviati a nil a meno che il tipo restituito dal metodo sia un oggetto, qualsiasi tipo puntatore, o intero inferiore o uguale a sizeof(void*).

Le variabili di istanza del ricevente

Un metodo ha accesso automatico alle variabili di istanza dell'oggetto receiver. Non avete bisogno di passarle al metodo come argomenti. Per esempio, il metodo primaryColor illustrato sopra non prende argomenti, ma può ancora trovare il colore primario per otherRect e restituirlo. Ogni metodo presuppone il receiver e le sue variabili di istanza, senza doverle dichiarare come argomenti.
Questa convenzione semplifica il codice sorgente Objective-C. Supporta inoltre il pensiero OO riguardo gli oggetti e i messaggi. Messaggi sono inviati ai receivers quanto le lettere sono consegnate a casa tua. Gli argomenti dei messaggi portano informazioni dall'esterno al receiver; non hanno bisogno di portare il receiver stesso.
Un metodo ha accesso automatico solo alle variabili di istanza del receiver. Se esso richiede informazioni riguardo a una variabile memorizzata in un altro oggett, deve inviare un messaggio all'oggetto chiedendogli di rivelare il contenuto della variabile. I metodi primaryColor e isFilled mostrati sopra sono usati per questo scopo.

Polimorfismo

Come gli esempi sopra illustrano, messaggi in Objective-C appaiono nella stessa posizione sintattica delle chiamate a funzioni standard in C. Ma, poichè i metodi "appartengono a" un oggetto, i messaggi si comportano differentemente rispetto alle chiamate di funzioni. In particolare, un oggetto può essere operato solo dai metodi che sono stati definiti per esso. Non può confonderli con messaggi definiti per altri tipi di oggetti, anche se un altro oggetto ha metodi con lo stesso nome. Questo significa che due oggetti possono rispondere diversamente allo stesso messaggio. Per esempio ogni tipo di oggetto invia un messaggio display per poter mostrare se stesso in un modo unico. Un cerchio e un rettanolo risponderebbero diversamente a istruzioni identiche per seguire il cursore.
Questa caratteristica, che si chiama polimorfismo, gioca un ruolo significante nella progettazione di programmi OO. Insieme con il dynamic binding permette di scrivere codice che potrebbe essere applicato a un qualsiasi numero di diversi tipi di oggetti, senza che tu debba scegliere ogni volta che scrivi il codice di che tipo di oggetti si tratta. Potrebbero anche essere oggetti che saranno sviluppati in seguito, da altri programmatori che lavoreranno su altri progetti. Se scrivi codice che invia un messaggio display a una variabile id, qualsiasi oggetto che ha un metodo display sarà un potenziale receiver.

Dynamic Binding

Una differenza cruciale tra chiamate di funzione e messaggi è che una funzione e i suoi argomenti sono uniti insieme nel codice compilato, ma un messaggio e un oggetto ricevente non sono uniti finché il programma non è in esecuzione ed il messaggio è inviato. Quindi, l'esatto metodo che è invocato per rispondere a un messaggio può essere determinato solo a runtime, non quando il codice è compilato.
Il metodo preciso che un messaggio invoca dipende dal ricevente (receiver). Differenti riceventi possono avere diverse implementazioni per lo stesso nome di metodo (polimorfismo). Il compilatore per trovare la giusta implementazione di metodo per un messaggio, dovrebbe sapere che tipo di oggetto è il ricevente - a che classe appartiene. Questa è un'informazione che il ricevente è abilitato a rivelare a runtime quando riceve un messaggio (dynamic typing), ma non è disponibile per le dichiarazioni dei tipi trovate nel codice sorgente.
La selezione di un'implementazione di metodo accade a runtime. Quando un messaggio è inviato, una routine di messaging di runtime guarda il ricevente e il metodo nominato nel messaggio. Individua l'implementazione del metodo corrispondente del ricevente, "chiama" il metodo, e gli passa un puntatore alle variabili di istanza del ricevente.
Questo dynamic binding (collegamento dinamico) dei metodi ai messaggi funziona con il polimorfismo per dare alla programmazione OO più flessibilità e potenza. Dato che ogni oggetto può avere la sua propria versione di un metodo, un programma può raggiungere una varietà di risultati, non variando il messaggio in se stesso, ma variando solo l'oggetto che riceve il messaggio. questo può essere fatto quando il programma è in esecuzione; i receivers possono essere decisi al volo e possono essere resi dipendenti da fattori esterni come le azioni dell'utente.
Quando si esegue codice basato su un Application Kit, ad esempio, utenti determinano che oggetti ricevono i messaggi dai comandi di menu come Taglia, Copia e Incolla. Il messaggio va a qualsiasi oggetto controlla la selezione attuale. Un oggetto che mostra testo può reagire a un messaggio copy diversamente da un oggetto che mostra immagini scannerizzate. Un oggetto che rappresenta un insieme di forme potrebbe rispondere diversamente da un Rettangolo. Dato che i messaggi non selezionano i metodi (i metodi non sono legati al messagio) fino al runtime, queste differenze sono isolate in metodi che rispondono al messaggio. Il codice che invia il messaggio non si deve interessare di loro; non deve neanche enumerare le possibilità. Ogni applicazione può inventare i suoi propri oggetti che rispondono nel loro proprio modo ai messaggi copy.
Objective-C porta il dynamic binding un passo avanti e permette anche al messaggio inviato (il metodo selettore) di essere una variabile che è determinata a runtime. Questo sarà discusso in seguito.

Dynamic Method Resolution

Puoi fornire implementazioni di classi e istanziare metodi a runtime usando il dynamic method resolution. Vedi Dynamic Method Resolution in the Objective-C Runtime Programming Guide per ulteriori dettagli

Sintassi Punto

Objective-C fornisce un operatore punto (.) che offre una sintassi compatta e conveniente che potete usare come alternativa alla notazione con parentesi quadre ([]s) per invocare metodi accessori. è particolarmente utile quando vuoi accedere o modificare una proprietà che è una proprietà di un altro oggetto.

Uso della Sintassi Punto

Anteprima:
Puoi usare la sintassi punto per invocare metodi accessori usando lo stesso pattern di accedere a elementi di strutture come illustrato nel seguente esempio:

myInstance.value = 10;

printf("myInstance value: %d", myInstance.value);

La sintassi punto è trasformata dal compilatore in invocazioni di metodi acessori (così non accedi direttamente a una variabile di istanza). Il codice di esempio scritto sopra è esattamente equivalente al seguente:

[myInstance setValue:10];

printf("myInstance value: %d", [myInstance value]);

Uso generale
Puoi leggere e scrivere proprietà usando l'operatore punto (.), come illustrato nel seguente esempio.
Listing 1-1 Accedere a proprietà usando la sintassi punto

Graphic *graphic = [[Graphic alloc] init];


NSColor *color = graphic.color;

CGFloat xLoc = graphic.xLoc;

BOOL hidden = graphic.hidden;

int textCharacterLength = graphic.text.length;



if (graphic.textHidden != YES) {

graphic.text = @"Hello";

}

graphic.bounds = NSMakeRect(10.0, 10.0, 20.0, 120.0);

(@"Hello"è una costante NSString object”)
Accedere a una proprietà chiama il metodo get associato alla proprietà, coì come settarla invoca il metodo set associato alla proprietà. A dispetto delle apparenze, la sintassi punto quindi preserva l'incapsulamento, infatti non accedi direttamente alle variabili di istanza. Il seguente listato è equivalente al codice mostrato sopra, ma usa la sintassi a parentesi quadre:
Listing 1-2 Accedere a proprietà usando la sintassi a parentesi quadre

Graphic *graphic = [[Graphic alloc] init];



NSColor *color = [graphic color];

CGFloat xLoc = [graphic xLoc];

BOOL hidden = [graphic hidden];

int textCharacterLength = [[graphic text] length];



if ([graphic isTextHidden] != YES) {

[graphic setText:@"Hello"];

}

[graphic setBounds:NSMakeRect(10.0, 10.0, 20.0, 120.0)];

Un vantaggio della sintassi punto è che il compilatore può segnalare un errore quando individua una write a una proprietà readonly, considerando che nel migliore dei casi può solo generare un metodo non dichiarato che avverte che hai invocato un metodo non-esistente setProperty: che fallirà a runtime.
Per le proprietà del tipo adatto del linguaggio C, il significato assegnazioni composte è ben definito. ad esempio, puoi aggiornare la proprietà lunghezza di un'istanza di NSMutableData usando assegnamenti composti:

NSMutableData *data = [NSMutableData dataWithLength:1024];

data.length += 1024;

data.length *= 2;

data.length /= 4;

che è equivalente a:

[data setLength:[data length] + 1024];

[data setLength:[data length] * 2];

[data setLength:[data length] / 4];

C'è un caso in cui le proprietà non possono essere usate. Considera il seguente frammento di codice:

id y;

x = y.z; // z is an undeclared property

Nota che y è nontipata e la proprietà z non è dichiarata. Ci sono diversi modi in cui questo può essere interpretato. Dato che è ambiguo, ilo statemente è trattato come un errore di proprietà non dichiarata. Se z è dichiarata, allora non è ambiguo se c'è solo una dichiarazione di una proprietà z, finchè avranno tutti lo stesso tipo (tipo BOOL) allora è legale. Una sorgente di ambiguità potrebbe anche sorgere da una proprietà dichiarata readonly.
Valori nil
Se un valore nil è incontrato durante l'attraversamento di proprietà, il risultato è lo stesso di inviare il messaggio a nil. Per esempio le seguenti coppie sono tutte equivalenti:

// each member of the path is an object

x = person.address.street.name;

x = [[[person address] street] name];



// the path contains a C struct

// will crash if window is nil or -contentView returns nil

y = window.contentView.bounds.origin.y;

y = [[window contentView] bounds].origin.y;



// an example of using a setter....

person.address.street.name = @"Oxford Road";

[[[person address] street] setName: @"Oxford Road"];

Self
Se vuoi accedere a proprietà di self usando metodi accessori, devi esplicitamente chiamare self come illustrato in questo esempio:

self.age = 10;

Se non vuoi usare self., Acedi alla variabile di istanza direttamente. nel seguente esempio, il metodo set per la proprietà age non è invocato:

age = 10;

Performance and Threading
La sintassi genera codice equivalente all'invocazione standard di un metodo. come risultato, il codice che usa la sintassi punto esegue esattamente la stessa cosa di un codice scritto direttamente usando metodi accessori. Dato che la sintassi punto semplicemente invoca i metodi, non sono introdotte ulteriori dipendenze del thread come risultato del suo uso.

Sommario d'uso

aVariable = anObject.aProperty;

Invoca il metodo aProperty e assegna il valore restituito a aVariable. Il tipo di proprietà aProperty e il tipo di aVariable devono essere compatibili, altrimenti avrai un warning nella compilazione.

anObject.name = @"New Name";

Invoca il metodo setName: su anObject, passando @"New Name" come argomento.
Ottieni un warning nella compilazione se setName: non esiste, se la proprietà name non esiste, o se setName: restituisce qualcosa ma void.

xOrigin = aView.bounds.origin.x;

Invoca il metodo bounds e definisce xOrigin a essere il valore dell'elemento della struttura di origin.x del NSRect restituito da bounds.

NSInteger i = 10;

anObject.integerProperty = anotherObject.floatProperty = ++i;

Assegna 11 a entrambi anObject.integerProperty e anotherObject.floatProperty. Il lato destro dell'assegnamento è pre-valutato e il risultato è passato a setIntegerProperty: e setFloatProperty:. Il risultato prevalutato è costretto come richiesto ad ogni punto dell'assegnamento.

Uso Errato

I seguenti patterns sono fortemente sconsigliati.

anObject.retain;

Genera un warning (warning: value returned from property not used.).

/* method declaration */

- (BOOL) setFooIfYouCan: (MyClass *)newFoo;



/* code fragment */

anObject.fooIfYouCan = myInstance;

Genera un compiler warning che setFooIfYouCan: non sembra apparire un metodo di set perchè non restituisce (void).

flag = aView.lockFocusIfCanDraw;

Invoca lockFocusIfCanDraw e assegna il valore restituito a flag. Non genera warning a menoche il tipo di flag non combacia con il tipo che il metodo ritorna.

/* property declaration */

@property(readonly) NSInteger readonlyProperty;

/* method declaration */

- (void) setReadonlyProperty: (NSInteger)newValue;



/* code fragment */

self.readonlyProperty = 5;

Dato che la proprietà è dichiarata readonly, questo codice genera un compiler warning (warning: assignment to readonly property 'readonlyProperty'). Perchè il metodo che setta è presente, funzionerà a runtime, ma semplicemente aggiungere un setter per una proprietà non implica readwrite.

---

Fine prima parte

Finisce qui questo primo articolo dedicato alle basi del linguaggio di programmazione Objective C. Spero di realizzare un'utile manuale disponibile a tutti. Segnalatemi eventuali errori, o commentate l'articolo se l'avete trovato utile, in modo da incentivarmi a proseguire con le traduzioni.

Guida Objective-C parte seconda: Le Classi