Share
Ce chapitre est conçu pour vous aider à vous habituer au style de programmation Objective-C. À la fin de ce chapitre, vous pourrez instancier des objets, créer et appeler des méthodes et déclarer des propriétés. Rappelez-vous que le but est de fournir un très bref aperçu des principaux aspects de l’objectif Objective-C orienté objet, et non une description détaillée de chaque composant. Les chapitres suivants complètent nombre des détails conceptuels omis de ce chapitre.
Échantillon de code inclus: HelloObjectiveC With Class
Ouvrons un peu et créons un nouveau fichier Objective-C. Dans l'IDE Xcode, accédez à Fichier > Nouveau > Fichier… ou utilisez le Cmd + N raccourci pour ajouter un fichier à votre projet. La boîte de dialogue suivante vous permet de sélectionner le type de fichier que vous souhaitez créer. Sous le Cacao Touch catégorie, sélectionnez Classe Objective-C.
L'icône de la classe Objective-C Vous avez la possibilité de spécifier un nom pour votre nouvelle classe. Appelons notre classe La personne. Pour la classe parente, utilisez NSObject, qui est l'objet de premier niveau duquel toutes les classes Objective-C héritent.
Définir une nouvelle classe de personne En cliquant Suivant ouvrira un navigateur de fichiers et vous demandera d’entrer un Groupe pour votre classe, ainsi qu'un Cible. Utilisez la valeur par défaut Groupe, qui devrait être HelloObjectiveC. Les groupes sont un mécanisme spécifique à Xcode pour regrouper des fichiers similaires, mais ils ne sont pas mis en œuvre au niveau du fichier. Notre nouvelle classe apparaîtra dans le même dossier que le reste des fichiers du projet, quel que soit le groupe dans lequel elle se trouve. Les cibles, assure-toi HelloObjectiveC est sélectionné. Cela garantit que la nouvelle classe est compilée chaque fois que nous construisons la cible HelloObjectiveC.
Sélection des cibles de construction pour la nouvelle classe Enfin, cliquez sur Créer pour créer la classe. Dans le navigateur de fichier Xcode, vous devriez maintenant trouver deux nouvelles classes: Personne.h et Personne.m. Tout comme le langage de programmation C, Objective-C utilise .h en tant qu'extension pour les fichiers d'en-tête, qui contiennent l'interface d'une fonction ou d'une classe particulière, il ne faut pas la confondre avec une interface C #, appelée protocole en Objective-C. le .m fichier est l'implémentation correspondante pour le La personne classe.
La séparation de l'interface d'une classe de son implémentation permet de masquer les détails de l'implémentation des objets tiers. Les autres fichiers devant interagir avec la classe importent le entête fichier-jamais le la mise en oeuvre fichier. Ceci fournit la définition abstraite nécessaire pour appeler des méthodes et des propriétés d'accès tout en étant complètement indépendant de l'implémentation de la classe..
Dans le navigateur de projet, sélectionnez Personne.h pour l'ouvrir dans le panneau d'édition. Vous devriez voir le code Objective-C suivant:
#importation@interface Person: NSObject @end
le #importation directive inclut un autre fichier dans le contexte actuel. L'inclusion d'un fichier d'en-tête nous donne accès à toutes les classes et fonctions qu'il définit. Dans ce cas, nous avons inclus le framework Foundation. Le framework Foundation définit les constructions de base du langage Objective-C: éléments tels que des chaînes, des tableaux, des dictionnaires, etc..
le @interface directive commence une interface pour une classe. Ensuite vient le nom de la classe, La personne, suivi de deux points et de la classe parente, NSObject. Comme mentionné plus tôt, NSObject est l'objet de niveau supérieur dans Objective-C. Il contient les méthodes nécessaires à la création et à la destruction d'instances, ainsi que d'autres fonctionnalités utiles partagées par tous les objets..
Toutes les méthodes ou propriétés seraient déclarées avant la @fin directive, mais maintenant, Personne.h est une interface vide. Nous allons changer cela dans une minute, mais d'abord, jetons un coup d'œil au fichier d'implémentation., Personne.m:
#import "Person.h" @implementation Person @end
Cela ressemble beaucoup au fichier d’en-tête, mais il inclut le Personne.h entête. Fichiers d'implémentation doit inclure leur en-tête associé, sinon ils ne pourront pas trouver la classe qu'ils essayent d'implémenter.
Notez également que cette #importation directive utilise des guillemets au lieu de crochets. Les guillemets doivent être utilisés pour importer local en-têtes, tandis que les parenthèses indiquent global en-têtes. Les en-têtes globaux se trouvent en dehors du projet et sont liés au compilateur pendant le processus de construction. Les cadres standard d’Apple sont toujours inclus entre crochets, tandis que vos fichiers de projet doivent être importés avec des guillemets..
Et bien sûr, le .m le fichier utilise le @la mise en oeuvre directive au lieu de @interface. Notez que vous ne pas devez spécifier ici la classe parente, car cette information est déjà contenue dans l'en-tête.
Ensuite, nous allons ajouter une déclaration de méthode à la La personne classe. Rappelez-vous qu'il s'agit d'un processus en deux étapes: nous devons d'abord l'ajouter à l'interface, puis la mise en œuvre. Alors, change Personne.h à ce qui suit:
#importation@interface Person: NSObject - (void) sayHello; @fin
Comme vous pouvez le constater, les méthodes d’instance sont déclarées avec un trait d’union, le type de retour entre parenthèses (vide), suivi du nom de la méthode et d'un point-virgule. Maintenant que nous avons cela dans l'interface, passez à Personne.m définir la mise en œuvre. Notez que Xcode a ajouté un petit triangle jaune à côté du @la mise en oeuvre ligne. Si vous cliquez dessus, vous trouverez un message d'avertissement qui dit Mise en œuvre incomplète. C'est l'une des nombreuses fonctionnalités de débogage de Xcode. Réglons ce problème en changeant Personne.m à ce qui suit:
#import "Person.h" @implementation Person - (void) sayHello NSLog (@ "Bonjour, je m'appelle HAL."); @fin
Comme pour la déclaration d'interface, l'implémentation d'une méthode d'instance commence par un trait d'union, le type de retour et le nom de la fonction. L'implémentation elle-même est définie entre accolades après le nom de la méthode, comme une méthode C #. Pour dis bonjour, nous venons d'envoyer un message à la console en utilisant NSLog ().
Au fur et à mesure que vous tapez, Xcode présente des options d'auto-complétion et devrait également avoir fermé vos accolades pour vous. Ces comportements peuvent être modifiés en accédant à Xcode > Préférences… dans la barre de menu et en cliquant sur le Édition de texte icône.
Essayons instancier notre La personne classe et appelant notre nouveau dis bonjour méthode. Rappelez-vous que comme tout programme C, principale() est le point d'entrée dans notre HelloObjectiveC application. Donc, retour dans main.m, changement NSLog (@ "Hello, World!"); à ce qui suit:
#importation#import "Person.h" int main (int argc, const char * argv []) @autoreleasepool Person * somePerson = [[Person alloc] init]; retourne 0;
le Personne * une personne expression déclare une variable appelée une personne quelconque et dit au compilateur qu'il va contenir une instance du La personne classe. L'astérisque à côté du nom de la variable indique qu'il s'agit d'un aiguille, qui est le moyen le plus courant de référencer des objets dans Objective-C. Nous discuterons des pointeurs plus en détail plus tard.
Ensuite, le [[Person alloc] init] le code crée une nouvelle instance du La personne classe. La notation entre crochets peut prendre un certain temps pour s'y habituer, mais elle est conceptuellement identique aux parenthèses utilisées pour les appels de méthodes en C # et dans d'autres langages de style Simula. L'exemple de code précédent est équivalent au suivant en C #:
Person somePerson = new Person (); somePerson.init ();
le [Personne allouer] appel alloue la mémoire requise pour la nouvelle instance, et le init call est utilisé pour exécuter tout type de code d'initialisation personnalisé. Notez qu’il n’existe pas de "méthodes de constructeur" dans Objective-C comme en C # ou C ++ - vous devez appeler manuellement le init méthode (ou une variante de celle-ci) pour configurer votre objet. En conséquence, la quasi-totalité des objets créés dans Objective-C est un processus en deux étapes: allouer, puis initialiser. Vous verrez ce modèle assez souvent dans les programmes Objective-C.
Maintenant que nous avons un objet avec lequel travailler, nous pouvons appeler notre dis bonjour méthode. Notez que la terminologie correcte dans Objective-C est "envoyer un message", pas "appeler une méthode", mais pour nos besoins, nous pouvons les traiter comme des synonymes. Ajouter la ligne suivante à main.m:
[certains disent bonjour];
Comme le allouer/init méthodes de l'exemple précédent, l'invocation de méthode personnalisée utilise des crochets. Encore une fois, cela revient à exécuter somePerson.sayHello () en C #. L'exécution de votre programme devrait afficher Bonjour, je m'appelle HAL. dans le panneau de sortie Xcode:
Sortie générée à partir de la méthode sayHello Outre les crochets, les conventions de dénomination des méthodes d'Objective-C constituent l'un des principaux ajustements pour les développeurs issus de C #, C ++, Java, Python ou de tout autre langage autre que Smalltalk. Les noms de méthode Objective-C sont conçus pour être aussi descriptifs que possible. L’idée est de définir une méthode de telle sorte que sa lecture à voix haute vous dise littéralement ce qu’elle fait..
Par exemple, ajoutons un prénom paramètre à notre dis bonjour méthode. Tout d’abord, nous devons mettre à jour la déclaration de la méthode dans l’en-tête (Personne.h):
- (void) sayHelloToName: (NSString *) aName;
Ajouter un paramètre réellement changé le nom de la fonction-le paramètre n'est pas une entité isolée telle qu'elle est en C # (par exemple., sayBonjour (nom)). le (NSString *) partie définit le type de données du paramètre, et un nom est la variable réelle accessible dans le code d'implémentation, que nous définirons maintenant. Changement dis bonjour dans Personne.m à l'exemple de code qui suit. Xcode devrait compléter automatiquement le nouveau nom de la méthode lorsque vous commencez à la saisir.
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Hello% @, mon nom est HAL.", aName);
Cette nouvelle NSLog () la configuration utilise une chaîne de format pour ajouter le un nom argument à la sortie. Nous couvrirons NSLog () plus en détail dans le chapitre suivant, mais pour l’instant, tout ce que vous devez savoir, c’est que cela remplace % @ dans la chaîne de format avec un nom. Ceci est à peu près équivalent à String.Format () en C #.
Appel du paramètre un nom peut sembler redondant avec sayHelloToName, mais cela a plus de sens quand vous lisez la méthode telle qu'elle serait invoquée. Dans main.m, changer la dis bonjour appeler pour:
[somePerson sayHelloToName: @ "Bill"];
Maintenant, vous devriez pouvoir exécuter votre programme et voir Bonjour Bill, je m'appelle HAL. dans le panneau de sortie. Comme vous pouvez le constater, les noms de méthodes Objective-C sont verbeux, mais assez instructifs. Contrairement au style C # sayBonjour (nom) invocation, Objective-C rend très difficile le transfert accidentel d’une valeur erronée à une méthode. Bien entendu, les noms des méthodes sont longs, mais c'est pourquoi Xcode offre une fonctionnalité aussi pratique d'auto-complétion. Nous verrons beaucoup plus d'exemples verbeux (et plus pratiques) de noms de méthodes Objective-C dans ce livre..
Exemple de code inclus: With Properties
Comme avec tout langage orienté objet, les méthodes Objective-C sont un moyen de manipuler l'état interne d'un objet. Cet état est généralement représenté comme un ensemble de propriétés attachées à un objet. Par exemple, nous pouvons ajouter un prénom propriété à notre La personne interface pour stocker dynamiquement le nom de chaque instance:
@property (copy) NSString * name;
le @propriété déclaration commence une nouvelle propriété, la (copie) tuple spécifie le comportement de la propriété, et NSString * name définit une propriété appelée prénom qui contient une valeur de chaîne. En règle générale, les déclarations de propriété sont placées avant les déclarations de méthode, mais tant que cela se situe entre @interface et @fin dans Personne.h, ça ira.
En utilisant @propriété au lieu d'attributs privés vous donne accès à la @ synthétiser directive dans le fichier d'implémentation. Il vous permet de créer automatiquement des méthodes d'accesseur pour la propriété associée. Par exemple, dans Personne.m, ajoutez ce qui suit (encore une fois, les implémentations de propriétés arrivent généralement avant les implémentations de méthodes):
@synthesize name = _name;
@ synthétiser est une directive de commodité qui indique au compilateur de générer des méthodes getter et setter pour la propriété. La partie après la = signe est utilisé comme variable d’instance (membre privé) de la propriété, ce qui signifie que nous pouvons utiliser _prénom pour accéder à la propriété de nom à l'intérieur de Personne.m. Par exemple, essayez de changer le sayHelloToName méthode pour:
- (void) sayHelloToName: (NSString *) aName NSLog (@ "Bonjour% @, mon nom est% @.", aName, _name);
Par défaut, le nom de la méthode getter est identique au nom de la propriété et le créateur a ensemble ajouté au nom de la propriété en majuscule. Ainsi, nous pouvons définir dynamiquement notre La personne nom de l'objet en changeant main.m à ce qui suit:
Person * somePerson = [[Person alloc] init]; [somePerson setName: @ "HAL 9000"]; [somePerson sayHelloToName: @ "Bill"];
L'exécution de votre programme devrait maintenant produire Bonjour Bill, je m'appelle HAL 9000.
Ce chapitre a présenté les composants de base d’une classe Objective-C. Nous avons appris à séparer les classes en interface ( .h) et les fichiers de mise en œuvre ( .m), instancier des objets, définir et appeler des méthodes et déclarer des propriétés. J'espère que vous vous sentez un peu plus à l'aise avec la notation entre crochets d'Objective-C et d'autres bizarreries syntaxiques.
Rappelez-vous que ce chapitre a été conçu pour être une introduction rapide aux concepts de POO d'Objective-C, et non une discussion approfondie de chaque composant. Dans les chapitres à venir, nous examinerons plus en détail les types de données, les déclarations de propriétés, les définitions de méthodes, ainsi que les modèles de conception courants des programmes Objective-C..
Cette leçon représente un chapitre de Objective-C Succinctly, un eBook gratuit de l’équipe de Syncfusion..
Accentsconagua