Il linguaggio Objective-C è un linguaggio di programmazione creato per permettere lo sviluppo di applicazioni tramite il sofisticato paradigma di programmazione object-oriented. Objective-C è definito come un piccolo ma potente set di estensioni allo standard ANSI C. Le estensioni introdotte sono principalmente basate su Smalltalk, uno dei primi linguaggi di programmazione orientati agli oggetti. Objective-C è stato quindi creato per offrire la possibilità ai numerosi programmatori C di lavorare, in modo semplice e diretto, con un linguaggio ad oggetti.

Gli ambienti di sviluppo object-oriented sono composti solitamente di diverse parti:

• Un lunguaggio di programmazione ad oggetti (nel nostro caso Objective-C)
• Una libreria di oggetti preconfezionati (ad esempio il framework Cocoa)
• Una suite di strumenti di sviluppo (Xcode, Interface Builder, Instruments)
• Un ambiente di runtime (iPhone Simulator)

Gli oggetti

Un oggetto è un entità che possiede dei dati a cui associa delle particolari operazioni che possono utilizzare o modificare i dati stessi. In Objective-C queste operaszioni sono conosciute come “Metodi degli oggetti”. I dati interessati sono le sue variabili di istanza. In sostanza la struttura di un oggetto è formata da alcuni dati (variabili) e un gruppo di procedure (metodi) in un un unico elemento.

Per esempio, se state scrivendo un programma di disegno che permette all’utente di creare un’immagine composta da linee, cerchi, rettangoli, testi, immagini bitmap e così via, dovreste creare delle classi per ogni elemento base che l’utente puo’ manipolare. Un oggetto rettangolo, per esempio, potrebbe avere variabili di istanza che identificano la posizione del rettangolo all’interno del disegno, la sua larghezza e la sua altezza. Altre variabili potrebbero invece definirne il colore, decidere se questo va riempito o meno con questo colore o che tipo di linea che deve essere usata per mostrare il rettangolo. La classe Rettangolo potrebbe inoltre avere metodi per settare questi valori, ovvero posizione, dimensione, colore, stato riempimento e tipo di linea insieme ad un metodo che mostra poi il tutto sul display.

In Objective-C le variabili di istanza di un oggetto sono interne all’oggetto. Generalmente è possibile accedere allo stato di un oggetto solo attraverso i suoi metodi (è inoltre possibile specificare se sottoclassi o altri oggetti possono accedere direttamente alle variabili di un oggetto secondo le direttive di visibilità). Per altri oggetti che necessitano di estrapolare dati da un oggetto, deve esistere un metodo che le fornisca. Per esempio, un Rettangolo potrebbe avere un metodo che mostra la sua dimensione e posizione.

Inoltre, un oggetto vede i soli oggetti che sono stati disegnati per esso, non si pussono quindi utilizzare, anche erroneamente, metodi destinati ad altri oggetti. Come nel C le funzioni “proteggono” le loro variabili locali nascondendole dal resto del programma, un oggetto nasconde le sue variabili e i suoi metodi.

Messaggi

Sintassi (standard)

Per dire ad un oggetto di fare qualcosa occorre inviargli un messaggio che gli dice di applicare un determinato metodo. In Objective-C l’espressione del messaggio va racchiusa tra parentesi quadre:

[receiver message]

Il ricevitore del messaggio (receiver) è un oggetto, mentre message è il messaggio che gli dice cosa deve fare. Nel codice il messaggio è semplicemente il nome del metodo più eventuali argomenti da passare. Quando il messaggio viene inviato, il sistema di runtime seleziona il metodo appropriato dal repertorio dell’oggetto ricevente e lo invoca.

Per esempio, questo messaggio dice all’oggetto myRectangle di invocare il suo metodo display, che non fa altro che mostrare il rettangolo stesso:

[myRectangle display];

Il messaggio termina con “;” che rappresenta il termine di un’istruzione in C e di conseguenza va utilizzato anche in Objective-C.

Il nome del metodo nel messaggio serve per selezionare appunto il metodo dal set di quelli disponibili. Per questo motivo i nomi dei metodi nei messaggi sono spesso definiti selettori.

I metodi possono inoltre accettare eventuali parametri, o “argomenti”. In un messaggio con un singolo argomento occorre inserire il simbolo “:” (duepunti) subito dopo il nome del metodo seguito quindi dall’argomento. Questo costrutto è chiamato keyword, le keyword sono formate dal nome del metodo, dal carattere “:” e a seguire l’argomento, come mostrato in questo esempio:

[myRectangle setWidth:20.0];

Il nome del metodo comprende quindi tutti i caratteri, inclusi i duepunti e l’argomento, ma non include elementi come il tipo di dato da restituire o i tipi di dato dei parametri. Il messaggio seguente, errato, dice all’oggetto myRectangle di settare la sua origine alle coordinate (30.0, 50.0):

// Questo è un esempio errato dell'uso di argomenti multipli*
[myRectangle setOrigin:30.0 :50.0];

*Nota: In C e di conseguenza in Objective-C tutto ciò che sta di seguito ai caratteri “//” è considerato un commento. Un commento non viene considerato in fase di compilazione del programma e il suo scopo è semplicemente di rendere più leggibile e comprensibile il codice sorgente delle applicazioni. I caratteri “//” vengono usati per inserire commenti di una sola riga. Se si volesse inserire un commento composto di più riche occorre semplicemente inserirlo tra i caratteri “/*” di inizio commento e “*/” di fine commento.

Dato che i due punti “:” sono parte del nome del metodo, il metodo dell’esempio errato appena citato risulta essere setOrigin::. Esso ha 2 simboli “:” e riceve due argomenti. In questo esempio in particolare il secondo argomento risulta privo di etichetta (prima dei “:”) e perciò è difficile determinare il tipo o lo scopo di questo argomento. Per questo è errato.

I nomi dei metodi dovrebbero includere un’etichetta che identifichi gli argomenti. Per esempio, il metodo citato sopra per la classe Rectangle potrebbe essere implementato con setOriginX:Y:

// Questo è un esempio corretto dell'uso di argomenti multipli
[myRectangle setOriginX: 30.0 y: 50.0];

Come nelle funuzioni in C, i metodi possono restituire dei valori. Il seguente esempio setta la variabile isFilled a YES se myRectangle è disegnato come un solido riempito, o NO se non ha riempimento ed è formato dalla sola linea.:

BOOL isFilled;
isFilled = [myRectangle isFilled];

Una variabile e un metodo possono avere lo stesso nome.

Un messaggio può essere inoltre nidificato all’interno di un altro. Qui ad esempio il colore di un rettangolo è impostato con il colore di un altro:

[myRectangle setPrimaryColor:[otherRect primaryColor]];

Sintassi col punto (dot syntax)

Objective-C offre la possibilità di usare un altro tipo di sintassi, alternativa alla notazione classica tra parentesi quadre [.. ..] grazie all’operatore punto “.” per invocare i metodi. Questa notazione è particolarmente utile quando si vuole accedere o modificare proprietà che sono di un altro oggetto.

E’ possibile usare la sintassi con il punto come mostrato nei seguenti esempi:

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

La porzione di codice qui sopra è esattamente equivalente alla seguente:

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

E’ possibile quindi usare questa sintassi come mostrato nel seguente esempio:

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);

Utilizzando la sintassi classica con le quadre dell’Objective-C avremmo dovuto scrivere:

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 di questa sintassi è che il compilatore può segnalare un errore quando, ad esempio, incontra un metodo che tenta di scrivere qualcosa in una prorietà in sola lettura.

E’ inoltre possibile usare istruzioni composte da entrambi i tipi di sintassi:

NSMutableData *data = [NSMutableData dataWithLength:1024];
data.length += 1024;
data.length *= 2;
data.length /= 4;

Che equivale a:

[data setLength:[data length] + 1024];
[data setLength:[data length] * 2];
[data setLength:[data length] / 4];

Di seguito altri esempi validi, mostrati utilizzando entrambi i tipi di sintassi:

// ciascun membro del percorso è un oggetto
x = person.address.street.name;
x = [[[person address] street] name];

/* Il percorso contiene una truttura C che andrà in crash 
se la finestra è nulla o contentView è nullo */
y = window.contentView.bounds.origin.y;
y = [[window contentView] bounds].origin.y;

// altro esempio
person.address.street.name = @"Oxford Road";
[[[person address] street] setName: @"Oxford Road"];

Self

Se si vuole accedere ad un metodo dell’oggetto stesso, occorre usare la sintassi mostrata di seguito:

self.age = 10;

Classi

Un programma object-oriented è tipicamente composto da una gran varietà di oggetti. Un programma basato sul framework Cocoa, (il set di sviluppo per Mac per intenderci), ad esempio, potrebbe avere oggetti come NSMatrix, NSWindow, NSDictionary, NSFont, NSText e molti altri. Questi programmi spesso usano inoltre più oggetti dello stesso tipo.

In Objective-C per definire gli oggetti, occorre definire le loro classi. La definizione della classe non è nient’altro che un prototipo per il tipo di oggetto. In esso vanno dichiarate le variabili di istanza e un set di metodi che saranno disponibili per tutti gli oggetti della classe.

Il compilatore creerà un solo oggetto accessibile per ogni classe, un oggetto che sa come costruire nuovi oggetti della stessa classe. L’oggetto classe è la versione compilata della classe, gli oggetti creati sono invece istanze di questa classe. Gli oggetti che eseguono il lavoro principali nel programma quindi sono delle istanze create dall’oggetto classe durante l’esecuzione.

Tutte le istanze di una classe hanno lo stesso set di metodi a disposizione e ovviamente lo stesso set di variabili, prese dallo stesso “stampo”.

Ogni oggetto avrà quindi le proprie variabili, mentre i metodi sono condivisi da tutte le istanze.

Per convenzione i nomi delle classi dovrebbero iniziare con una lettera maiuscola (come la classe dell’esempio sopra “Rectangle”). I nomi delle istanze, invece, dovrebbero iniziare con una lettera minuscola (ad esempio “myRectangle”)

Ereditarietà

Ogni nuova classe creata è basata su un’altra classe dalla quale eredita tutti i metodi e le variabili di istanza. La nuova classe semplicemente aggiunge o modifica ciò che eredita. Non è quindi necessario duplicare il codice ereditato.

L’ereditarietà collega quindi tutte le classi in una struttura gerarchica ad albero, con una sola classe alla radice. Quando scriviamo codice basato sul framework Foundation, l’oggetto alla radice è solitamente NSObject. Tutti gli oggetti al di sotto di questo ereditano quindi variabili e metodi, aggiungendone altri o modificandone alcuni ereditati. Tutti gli oggetti, escluso quello alla radice, hanno una classe subito sopra, dal quale ereditano tutto, chiamata superclasse e ogni oggetto ha o puo’ avere delle sottoclassi a cui trasmettere le sue variabili e i suoi metodi.

Di seguito un’immagine che mostra visivamente questa struttura gerarchica:

La figura sopra mostra la classe Square come una sottoclasse della classe Rectangle e la classe Rectangle è una sottoclasse di Shape, Shape è una sottoclasse di Graphic, e quest’ultima è una sottoclasse di NSObject. L’ereditarietà è cumulativa. Quindi un oggetto Square ha i metodi e le variabili definite in Rectangle, Shape, Graphic e NSObject, come se fossero definite direttamente nella classe Square. Questo è un modo semplice per dire che un oggetto Square non è solo un oggetto Square, ma anche un oggetto Rectangle, Shape, Graphic e NSObject.

Ogni classe puo’ essere vista come una specializzazione o un adattamento di un’altra classe. Ogni sottoclasse successiva modifica alcune parti di ciò che eredita, quindi, nel nostro esempio, la classe Square definisce solo il minimo necessario per modificare un rettangolo in un quadrato.

Quando definiamo una classe, la linkiamo nella gerarchia dichiarando la sua superclasse. Ogni classe che verrà creata deve essere una sottoclasse di un’altra, a meno che non stiate definendo una nuova classe radice.

Le potenziali superclassi disponibili sono in abbondanza. Cocoa include la classe NSObject e diversi framework contengono definizioni per oltre 250 classi aggiuntive. Alcune sono classi che potreste usare così come sono, mentre altre potrebbero essere adattate secondo le proprie esigenze definendo da esse nuove sottoclassi.

Molte classi del framework definisco tutto cio’ di cui possiamo aver bisogno , ma lasciano alcune specifiche per essere implementate in sottoclassi. Possiamo quidni creare oggetti molto sofisticati scrivendo solo una piccola porzione di codice e riusare l’ottimo codice prodotto dagli esperti programmatori dei framework.

Nella prossima lezione andremo a vedere come si definisce una classe da utilizzare nel nostro programma.

(Tradotto dalla documentazione ufficiale Apple)