iPhone » Sviluppo » Objective-C » Mobile

Objective-C: esporre proprietà in una classe

lunedì 14 dicembre, 2009

Vorrei mostrare e discutere alcuni esempi sul come aggiungere e manipolare proprietà in una Classe Objective-C. Un esempio classico, per l'appunto, è il seguente; nella definizione della nostra interfaccia di classe definiamo due proprietà nome e cognome:

PLAIN TEXT
Objective-C:
  1. // MyClass.h
  2. #import <Foundation/Foundation.h>
  3.  
  4. @interface MyClass : NSObject {
  5.     NSString *nome;
  6.     NSString *cognome;
  7. }
  8.  
  9. @property (retain) NSString *nome;
  10. @property (retain) NSString *cognome;
  11. @end

Nel file di implementazione inseriamo la dichiarazione @synthesize in modo tale che Xcode produca per noi i metodi getter e setter usati rispettivamente per leggere ed impostare le nostre due proprietà:

PLAIN TEXT
Objective-C:
  1. // MyClass.m
  2. #import "MyClass.h"
  3.  
  4. @implementation MyClass
  5.  
  6. @synthesize nome, cognome;
  7.  
  8. @end

Quando andremo ad utilizzare la nostra classe MyClass, cioè quando istanziaremo un oggetto di tipo MyClass, possiamo scrive:

PLAIN TEXT
Objective-C:
  1. // qualsiasi altra classe, come AppDelegate
  2. // nel file .h
  3. #import <UIKit/UIKit.h>
  4. #import "MyClass.h"
  5.  
  6. @class TestViewController;
  7.  
  8. @interface TesAppDelegate : NSObject <UIApplicationDelegate> {
  9.     UIWindow *window;
  10.     TestViewController *viewController;
  11.  
  12.     MyClass *miaClasse;
  13. }
  14.  
  15. // nel file .m
  16. miaClasse = [MyClass alloc];
  17. miaClasse.nome = @"Giovambattista";
  18. NSLog(@"miaClasse.nome = %@", miaClasse.nome);

Oppure, che è equivalente:

PLAIN TEXT
Objective-C:
  1. // sempre nel file .m
  2. [miaClasse setNome:@"Undolog"];
  3. NSLog(@"miaClasse.nome = %@",[miaClasse nome]);

Fin qui tutto bene. Tuttavia potrebbe fuorviare l'equivalenza delle "variabli" interne (ivar) con il nome della proprietà vera e propria. Per capire la differenza, ripropongo lo stesso esempio facendo a meno, questa volta, di @synthesize. Ora, quindi, dovremmo occuparci noi di scrivere i metodi getter e setter. Per sottolineare ulteriormente le differenze, rinominerò le variabili interne inserendo un underscore davanti al nome. Ma vediamo il codice:

PLAIN TEXT
Objective-C:
  1. #import <Foundation/Foundation.h>
  2.  
  3. @interface MyClass : NSObject {
  4.     NSString *_nome;
  5.     NSString *_cognome;
  6. }
  7.  
  8. - (NSString *) nome;                               // get
  9. - (NSString *) cognome;                            // get
  10.  
  11. - (void) setNome: (NSString *)stringaIngresso;     // set
  12. - (void) setCognome: (NSString *)stringaIngresso;  // set
  13.  
  14. @end

A differenza dell'esempio precedente i puntatori alla variabili interne (incapsultate) sono diventati _nome e _cognome. Inoltre troviamo quattro definizioni di metodi che rappresentano le nostre get e set. @property è scomparso, in quanto non serve più.
Vediamo il file di implementazione MyClass.m:

PLAIN TEXT
Objective-C:
  1. #import "MyClass.h"
  2.  
  3. @implementation MyClass
  4.  
  5. // get per "nome"
  6. - (NSString *) nome {
  7.     return _nome;
  8. }
  9. // set per "nome"
  10. - (void) setNome: (NSString *)stringaIngresso {
  11.     _nome = stringaIngresso;
  12. }
  13.  
  14. // get per "cognome"
  15. - (NSString *) cognome {
  16.     return _cognome;
  17. }
  18. // set per "cognome"
  19. - (void) setCognome: (NSString *)stringaIngresso {
  20.     _cognome = stringaIngresso;
  21. }
  22.  
  23. @end

Una classe così scritta potrà essere utilizzata esattamente come la precedente, cioè:

PLAIN TEXT
Objective-C:
  1. miaClasse = [MyClass alloc];
  2. miaClasse.nome = @"Giovambattista";
  3. NSLog(@"miaClasse.nome = %@", miaClasse.nome);
  4.  
  5. // Oppure, che è equivalente:
  6.  
  7. [miaClasse setNome:@"Undolog"];
  8. NSLog(@"miaClasse.nome = %@",[miaClasse nome]);

A livello didattico l'abbandono di @synthesize ci ha costretto a scrivere "da soli" i metodi di get e set, evidenziando - anche con l'aggiunta dell'underscore - le differenze tra il nome della proprietà e la sua ivar interna _nome.
A livello funzionale l'uso dei metodi personali get e set permette un reale controllo del dato prima della sua impostazione (o prima della sua lettura) e quindi un reale incapsulamento per proteggere la variabile interna.
Ad esempio sarebbe possibile impedire il passaggio di stringhe vuote alla proprietà nome:

PLAIN TEXT
Objective-C:
  1. - (void) setNome: (NSString *)stringaIngresso {
  2.     if( stringaIngresso == @"" ) stringaIngresso = @"senza nome";
  3.     _nome = stringaIngresso;
  4. }

Ulteriore variante

Se desiderate utilizzare le variabili interne con l'underscore davanti (chi rpoviene da Adobe Actionscript potrebbe essere abituato così) non è necessario abbandonare l'uso della direttiva @synthesize. Xcode permette infatti di "fondere" i metodi sopra indicati:

PLAIN TEXT
Objective-C:
  1. @synthesize nome = _nome;
  2. @synthesize cognome = _cognome;

Così facendo potremmo usare internamente il puntatore a _nome, "sintetizzato" - verso l'esterno - come proprietà nome. Inoltre, se è vero che l'uso di @synthesize produce la generazione automatica dei metodi (messaggi) di getter e setter, è vero anche che lo fa solo se non li trova, quindi se desiderate "implementare" un vostro metodo di getter e/o setter potete farlo anche se avete usato la direttiva @synthesize.

Allocazioni di memoria

Negli esempi di sopra ho omesso alcuni dettagli importanti ai fini di una reale implementazione. Prima di tutto non ho illustrato nessun metodo init(), utile ai fini dell'inizializzazione dell'oggetto e dei sui valori di default. Inoltre, manca l'aggiunta di un metodo dealloc():

PLAIN TEXT
Objective-C:
  1. // file MyClass.m
  2. #import "MyClass.h"
  3.  
  4. @implementation MyClass
  5.  
  6. - (id) init {
  7.     if ( self = [super init] ) {
  8.         _nome = @"Nome preimpostato";
  9.         _cognome = @"Cognome preimpostato";
  10.     }
  11.     return self;
  12. }
  13.  
  14. - (void) dealloc {
  15.     [_nome release];
  16.     [_cognome release];
  17.     [super dealloc];
  18. }
  19.  
  20. - (NSString *) nome {
  21.     return _nome;
  22. }
  23. - (void) setNome: (NSString *)stringaIngresso {
  24.     if( stringaIngresso == @"" ) stringaIngresso = @"senza nome";
  25.     _nome = stringaIngresso;
  26. }
  27.  
  28. - (NSString *) cognome {
  29.     return _cognome;
  30. }
  31. - (void) setCognome: (NSString *)stringaIngresso {
  32.     _cognome = stringaIngresso;
  33. }
  34.  
  35. @end

In futuro vedremo poi i dettagli sulle proprietà readonly, retain, etc... :)

Post correlati

Questo articolo ti è stato utile?: Per nientePocoAbbastanzaMoltoMoltissimo
Loading ... Loading ...

Tags: , , , , , , , , ,

Non ci sono commenti per questo Post

Lascia un commento

TAG XHTML PERMESSI: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> INSERIMENTO CODICE: 
<pre></pre>         // blocco generico
[code][/code]       // blocco generico
[as][/as]           // Actionscript
[css][/css]         // CSS Style Sheet
[html][/html]       // HTML
[js][/js]           // Javascript
[objc][/objc]       // Objective-C
[php][/php]         // PHP
[sql][/sql]         // SQL