Share
Maintenant que nous avons exploré quels types de données sont disponibles, nous pouvons parler de les utiliser de manière productive. Nous avons appris à déclarer des propriétés dans Hello, Objective-C, mais ce chapitre approfondit les nuances des propriétés publiques et des variables d'instance. Dans un premier temps, nous examinerons rapidement la syntaxe de base des propriétés et des variables d'instance, puis nous expliquerons comment utiliser les attributs de comportement pour modifier les méthodes d'accès..
Les propriétés peuvent être déclarées dans une interface en utilisant le @propriété directif. Comme un rapide examen, jetons un coup d'oeil à la Personne.h fichier que nous avons créé dans le chapitre Hello, Objective-C:
#importation@interface Person: NSObject @property (copy) NSString * name; @fin
Cela déclare une propriété appelée prénom de type NSString. le (copie) attribut indique au runtime quoi faire quand quelqu'un essaie de définir la valeur de prénom. Dans ce cas, il crée une copie indépendante de la valeur au lieu de pointer sur l'objet existant. Nous en parlerons plus en détail au chapitre suivant, Gestion de la mémoire..
Dans Hello, Objective-C, nous avons utilisé le @ synthétiser directive pour créer automatiquement des méthodes getter et setter. Rappelez-vous que la méthode getter est simplement le nom de la propriété et que la méthode de définition par défaut est setName:
#import "Person.h" @implementation Person @synthesize name = _name; @fin
Mais, il est également possible de créer manuellement les méthodes d'accès. Faire cela manuellement aide à comprendre quoi @propriété et @ synthétiser font dans les coulisses.
Échantillon de code inclus: ManualProperty
Tout d'abord, ajoutez une nouvelle propriété à la La personne interface:
@property (copy) NSString * name; @property unsigned int age;
Notez que nous stockons âge en tant que type de données primitif (pas un pointeur sur un objet), il n'a donc pas besoin d'un astérisque avant le nom de la propriété. Retour dans Personne.m, définir explicitement les méthodes d'accès:
- (unsigned int) age return _age; - (void) setAge: (unsigned int) age _age = age;
C'est exactement ce que @ synthétiser l'aurait fait pour nous, mais nous avons maintenant la chance de valider les valeurs avant qu'elles ne soient attribuées. Il nous manque cependant une chose: le _âge variable d'instance. @ synthétiser créé automatiquement un _prénom ivar, nous permettant de renoncer à cela pour la prénom propriété.
Les variables d'instance, également appelées ivars, sont des variables destinées à être utilisées à l'intérieur de la classe. Ils peuvent être déclarés à l’intérieur des accolades après soit le @interface ou @la mise en oeuvre directives. Par exemple, dans Personne.h, remplacez la déclaration d'interface par la suivante:
@interface Person unsigned int _age;
Ceci définit une variable d'instance appelée _âge, donc cette classe devrait maintenant compiler avec succès. Par défaut, les variables d’instance déclarées dans une interface sont protégé. La définition de classe C # équivalente serait quelque chose comme:
classe Person protected uint _age;
Les modificateurs d'étendue Objective-C sont les mêmes qu'en C #: les variables privées ne sont accessibles qu'à la classe qui les contient, les variables protégées sont accessibles à toutes les sous-classes et les variables publiques sont disponibles à d'autres objets. Vous pouvez définir la portée des variables d’instance avec le @privé, @protégé, et @Publique directives à l'intérieur de @interface, comme démontré dans le code suivant:
@interface Person: NSObject @private NSString * _ssn; @protected unsigned int _age; @public NSString * job;
Les ivars publics sont en fait un peu en dehors des normes Objective-C. Une classe avec des variables publiques agit plus comme une structure C que comme une classe; au lieu de la syntaxe de messagerie habituelle, vous devez utiliser le -> opérateur de pointeur. Par exemple:
Person * frank = [[Person alloc] init]; frank-> job = @ "astronaute"; NSLog (@ "% @", frank-> job); // PAS: [travail franc];
Cependant, dans la plupart des cas, vous souhaiterez masquer les détails de la mise en œuvre à l'aide d'un @propriété déclaration au lieu de variables d'instance publiques. De plus, les variables d’instance étant techniquement des détails d’implémentation, de nombreux programmeurs aiment garder tout variables d'instance privées. Dans cet esprit, les ivars déclarés dans @la mise en oeuvre sont privés par défaut. Donc, si vous deviez déplacer le _âge déclaration à Personne.m au lieu de l'en-tête:
@implementation Person unsigned int _age;
_âge serait portée en tant que privé variable. Gardez cela à l'esprit lorsque vous travaillez avec des variables d'instance dans des sous-classes, car les différentes valeurs par défaut pour la déclaration d'interface par rapport à la déclaration d'implémentation peuvent être déroutantes pour les nouveaux venus dans Objective-C..
Mais assez sur les variables d'instance; Revenons aux propriétés. Les méthodes d'accesseur peuvent être personnalisées à l'aide de plusieurs attributs de déclaration de propriété (par exemple,., (copie)). Certains des attributs les plus importants sont:
Accentsconagua
getter = getterName - Personnalisez le nom de la méthode d'accesseur getter. Rappelez-vous que la valeur par défaut est simplement le nom de la propriété.setter = setterName - Personnalisez le nom de la méthode d'accesseur setter. Rappelez-vous que la valeur par défaut est ensemble suivi du nom de la propriété (par exemple., setName ).lecture seulement - Faites en sorte que la propriété soit en lecture seule, ce qui signifie que seul un getter sera synthétisé. Par défaut, les propriétés sont en lecture-écriture. Cela ne peut pas être utilisé avec le setter attribut.non atomique - Indiquez que les méthodes d'accès n'ont pas besoin d'être thread-safe. Les propriétés sont atomiques par défaut, ce qui signifie que Objective-C utilisera un verrou / rétention (décrit dans le chapitre suivant) pour renvoyer le Achevée valeur d'un getter / setter. Notez cependant que cela ne ne pas garantir l'intégrité des données à travers les threads, simplement que les accesseurs et les setters seront atomiques. Si vous n'êtes pas dans un environnement threadé, les propriétés non atomiques sont beaucoup plus rapides.Un cas d'utilisation courant pour la personnalisation des noms de getter concerne les conventions de dénomination booléenne. Beaucoup de programmeurs préfèrent est aux noms de variables booléennes. C’est facile à mettre en œuvre via le getter attribut:
@property (getter = isEmployed) BOOL employé;
En interne, la classe peut utiliser le employé variable, mais d'autres objets peuvent utiliser le Est employé et setEmployed accesseurs pour interagir avec l'objet:
Person * frank = [[Person alloc] init]; [frank setName: @ "Frank"]; [frank setEmployed: YES]; if ([frank isEmployed]) NSLog (@ "Frank est employé"); else NSLog (@ "Frank est au chômage");
La plupart des autres attributs de propriété ont trait à la gestion de la mémoire, qui sera abordée dans la section à venir. Il est également possible d'appliquer plusieurs attributs à une même propriété en les séparant par des virgules:
@property (getter = isEmployed, en lecture seule) BOOL employé;
En plus des méthodes getter / setter, il est également possible d'utiliser la notation par points pour accéder aux propriétés déclarées. Pour les développeurs C #, cela devrait être beaucoup plus familier que la syntaxe de messagerie carrée d'Objective-C:
Person * frank = [[Person alloc] init]; frank.name = @ "Frank"; // Identique à [frank setName: @ "Frank"]; NSLog (@ "% @", frank.name); // Identique à [nom franc];
Notez que ceci n’est qu’une commodité: il se traduit directement par les méthodes getter / setter décrites précédemment. Notation par points ne peux pas être utilisé pour des méthodes d'instance.
Les propriétés font partie intégrante de tout langage de programmation orienté objet. Ce sont les données sur lesquelles les méthodes fonctionnent. le @propriété La directive est un moyen pratique de configurer le comportement d'une propriété, mais elle ne fait rien qui ne puisse être fait en créant manuellement les méthodes getter et setter..
Dans le chapitre suivant, nous verrons en détail comment les propriétés sont stockées en mémoire, ainsi que quelques nouveaux attributs de propriété permettant de contrôler ce comportement. Après cela, nous allons plonger dans les méthodes, qui complètent les outils centraux orientés objet de Objective-C.
Cette leçon représente un chapitre de Objective-C Succinctly, un eBook gratuit de l’équipe de Syncfusion..
