L'@interface d'une classe :

 

Cliquez sur le fichier Personnel.h pour visionner son contenu dans l'éditeur. Voici ce que vous devriez avoir :

// // Personnel.h // Tutoriel_CLU // // Created by __MyName__ on 30/11/2006. // Copyright 2006 __MyCompanyName__. All rights reserved. // #import @interface Personnel : NSObject { } @end

Si vous êtes habitués au C, une première chose ne devrait pas vous échapper, c'est la directive de préprocesseur "#import ". Cette directive est l'équivalent de "#include ", mais elle a l'avantage de gérer le problème des inclusions multiples. En effet, en C, lorsque vous définissez un fichier d'en-tête, vous devez faire attention, dans votre code, de bien spécifier ceci :

#ifndef MACLASSE_H_ #define MACLASSE_H_ //Vos déclarations #endif

Sinon, vous risquez d'inclure plusieurs fois le même fichier ce qui peut poser des problèmes à la compilation. La directive "#import" vous dispense d'écrire ces lignes de codes très lourdes. Elle dit au compilateur d'intégrer le fichier si et seulement si il ne l'a pas déjà été.

Ensuite, on rencontre la déclaration de la classe aussi appelée interface de la classe. Elle est entourée de 2 mots clés "@interface" et "@end ". Alors entre le mot clé "@interface " et les deux nous pouvons voir le nom de la classe, après se situe le nom de la classe dont hérite notre classe (Nous verrons la notion d'héritage plus tard), en Objective-C, (contrairement au C++), toutes les classes héritent obligatoirement de la classe NSObject directement ou indirectement (c'est-à-dire qu'elles peuvent hériter d'une classe qui elle-même hérite de NSObject).

 

Les Attributs :

Après cette ligne nous avons l'interface de la classe. À commencer par la déclaration des variables. En Objective-C, par définition et par défaut, toutes les variables d'instances, appelées aussi attributs, sont "protégés", c'est-à-dire qu'ils ne sont visibles que de l'intérieur de la classe ainsi que des classes qui héritent de celle-ci. Il est possible de modifier cette visibilité grâce aux mots clés suivants :

• @public : tous les attributs qui suivent jusqu'à l'accolade fermante ou un des autres mots clés qui suivent seront visibles de partout et par tous, c'est par définition à l'opposé du concept majeur de la POO : l'encapsulation, qui veut que les attributs soient invisibles et donc intouchables de l'extérieur. Ce n'est ) utiliser qu'en ultime recours !
• @protected (protégé) : les attributs qui suivent sont visibles par les objets de la classes et ceux qui héritent de la classe. C'est la valeur par défaut.
• @private (privé) : les attributs ne sont visibles que par les objets de la classe.

Ne vous en inquiétez pas, vous n'aurez pas à le sutiliser très très souvent, d'ailleurs je ne les utilise jamais. Je laisse la visibilité par défaut.

Toujours est-il qu'entre ces accolades se trouveront tous les attributs de notre classe. Ils se déclarent comme des variables toutes simples.
C'est-à-dire : type nom_variable;.
En objective-C, il n'est pas scandaleux de dire qu'une classe est aussi un type, par contre, si dans le cas des types génériques (type du C : int, float, double, void, etc. + type générique de l'Objective-C : BOOL, SEL, id) la déclaration peut se faire sous forme de variable statique ou de pointeurs, la déclaration des attributs d'une certaine classe se fait uniquement par pointeur. Si vous voulez vous faire incendier par le compilateur donnez-lui un objet défini statiquement. En effet, Objective-C est un langage entièrement dynamique, c'est-à-dire que les objets sont créés et supprimés de la mémoire à l'exécution du programme lorsqu'ils sont appelés... Pas au démarrage du programme comme dans le cas des variables statiques du C.

Donc ne venez pas vous plaindre que votre programme ne marche pas si vous m'avez oublié une étoile lors de la déclaration d'un objet, car si votre compilateur ne vous a pas crucifié c'est moi qui le ferai . Et ne vous avisez pas non plus d'oublier le point-virgule ";" à la fin de chaque déclaration !

Mais revenons à nos moutons. Pour l'instant, notre classe est rudimentaire, elle va avoir 3 attributs :

• numPers, de type entier, et qui contiendra le numéro du membre du personnel,
• nomPers, de type chaîne de caractères, qui contiendra le nom de la personne,
• numTel, de type chaîne et qui contiendra le numéro de téléphone, c'est une chîne parce qu'un entier ne peut pas commencer par zéro.

Le type chaîne est implémenté dans Cocoa, et il s'agit de NSString. Attention, c'est une chaîne fixée, c'est-à-dire qu'une fois attribuée elle n'est plus modifiable. Donc pour la modifier vous devez la supprimer et la réallouer.

Voici ce que cela devrait vous donner :
#import @interface Personnel : NSObject { int numPers; NSString * nomPers; NSString * numTel; } @end

Vous remarquez la présence des étoiles à côter des NSString, donc ce sont bien des pointeurs. Et bien sûr les points-virgule ";" .

 

Les Méthodes :

On va maintenant déclarer les méthodes de cette classe. Ces déclarations se font après l'accolade fermante et avant le mot clé "@end ". Et c'est à parti de là qu'on pourra commencer à entrevoir le côté pratique de ce langage.

Il y a deux types de méthodes :

• Les méthodes de classe : leur déclaration commence par un "+", ces méthodes manipulent généralement des éléments commun à tous les objets, par exemple le nombre d'instances (objets) d'une classe X allouées en mémoire.
• Les méthodes d'instance : leur déclaration commence par un "-", ces méthodes manipulent les objets eux-mêmes, elles permettent de modifier un attribut, d'effectuer une certaine action, etc.

La déclaration des méthodes ne ressemblent pas du tout à celle du C. Déjà pour commencer, les déclarations commencent par le signe "+" ou le signe "-", ensuite le type renvoyé par la méthode se trouvent entre parethèses. Puis ensuite vient le nom de la méthode, si la méthode ne comporte aucun paramètre d'entrée (pour accéder à un attribut par exemple), le nom de la méthode est immédiatement suivit du point-virgule, sans parenthèse. Si la Méthode prend des paramètres, leur type, entre parenthèses aussi, et leur nom sont précédés de deux point ":". Exemple :

• Méthode de classe avec paramètres :
  + (int) maMethodePrendUneChaine: (NSString*) chaine etUnEntier: (int) nombre;
• Méthode de classe sans paramètre : + (void) monAutreMethode;
• Méthode d'instance avec paramètres : - (id) initialiseAvecNom: (NSString*) nom;
• Méthode d'instance sans paramètre : - (NSString*) nom;

Ce genre de déclaration est surprenant n'est-ce pas??? Déjà vous pouvez remarquer qu'à chaque nouveau paramètre vous devez ajouter un ":" précédé ou non de sa signification. En effet, je pourrais très bien définir une fonction f prennant 3 paramètres de cette façon : "- (float) f: (float): (float): (float)", mais qui comprendrait ce qu'elle fait ? Alors voilà les conventions :

• Les caractères admis dans les noms des fonctions sont toujours les mêmes : A-Z, a-z, 0-9 et "_", pas de caractères accentués et autres caractères spéciaux !
• Un nom de fonction commence par une minuscule, sûrement pas par un chiffre mais au milieu du nom pas de problème,
• Chaque nouveau mot porte une majuscule,
• On nomme chaque paramètre dans la déclaration, même si c'est inutile, pour permettre la compréhension,
• On écrit des phrases, généralement en anglais, pour indiquer ce que fais la fonction et chaque paramètre,
• Pour les méthodes renvoyant des attributs d'instance ou de classe, on donne le nom de l'attribut à la fonction. En ce qui concerne les méthodes qui renvoient un booléen (BOOL), c'est-à-dire vrai ou faux (YES ou NO en Objective-C), leur nom se compose de l'adjective précédé de "is" (est), exemple "isSelectable" (estSelectionnable)
• Les méthodes modifiant un attribut commencent par "set" (attribuer/modifier) suivit du nom de l'attribut, exemple : "setSelectable:".

Ceux qui connaissent le C++ doivent se demander si la surcharge des méthodes est possibles. La surcharge est la possibilité de donnée à deux fonctions/méthodes différentes le même nom, elles seront alors différentes, pour le compilateur, par le nombre et les types des paramètres qu'elles récupèrent. Le compilateur gère ça en créant des étiquettes, à chaque méthode elle attribue une étiquette qui indique le nom de la méthode, le nombre de paramètre, les types de paramètres et leur ordre. En Objective-C la surcharge n'existe pas ! D'ailleurs c'est vous qui définissez les étiquettes, il s'agit en fait de leur nom complet, les deux points compris, par exemple, ma méthode de classe de tout à l'heure a pour étiquette et nom : "maMethodePrendUneChaine:etUnEntier:", vous pouvez voir que les types ne sont pas pris en compte dans la définition. C'est à la fois un avantage et un problème : si vous avez à redéfinir les types pris par une méthode le compilateur ne s'en offusquera pas. Par contre, ça le gènera si vous donnez à la fonction un paramètres de type différent... Surtout au niveau de l'exécution ! Sauf si il s'agit d'un type générique, là il y a moins de problème. Mais soyez tout de même vigilants !

 

Je reviens toujours un peu au C++ car il a l'avantage de posséder pratiquement tous les concept possibles et imaginables en POO. Nous allons voir quelles méthodes implémenter dans notre classe. En C++, toute classe possède ce qu'on appelle un constructeur (au moins un), c'est une méthode qui est appelé dès l'instanciation de l'objet et qui initialise celui-ci en lui attribuant un espace mémoire. Sur Objective-C cela s'appelle l'initialisation et ça se fait en deux étapes : Allocation de l'espace mémoire puis Initialisation des attributs. Ces deux étapes nécessites chacune une méthode distincte, et sur ces deux méthodes l'une d'elle doit obligatoirement être redéfinie par le développeur (vous), il s'agit de l'initialisation, il faut noter qu'il est aussi courant de définir une méthode (de classe généralement) qui fait les deux étapes elle-même. Ces méthodes renvoient toujours un (id) qui est le type objet par défaut (il s'agit d'un pointeur sur un objet ). Leur nom commence généralement par "init", elles peuvent ou non prendre des paramètres.

En C++, nous avons aussi un destructeur unique par classe, ce genre de méthodes, pas toujours nécessaire selon les attributs de la classe, est appelé lors du déréférencement de votre objet et permet de vider l'espace mémoire, utilisé par celui-ci, correctement. En Objective-C, cette méthode existe et est aussi obligatoire, sauf dans le cas d'une méthode n'étant pas destinée à être instanciée, auquel cas la méthode d'initialisation est aussi inutile. Elle porte le nom de "dealloc" (désalouer, sous entendu la mémoire utilisée par l'objet), c'est une méthode d'instance et elle retourne un (id), vous pouvez aussi ne pas mettre de valeur de retour, le compilateur comprendra quand même... Pour lui le type retourné par défaut des méthodes est le type (id).

Maintenant que tout est dit sur les deux méthodes nécessaires, nous allons implémentés les déclarations de nos méthodes, voici une liste non-exhaustive des méthodes, si vous pensez qu'il en faudrait plus, vous pouvez y aller :
+ (id) personnelWithNom: (NSString*) unNom; // Allocation + Initialisation avec le nom du personnel + (id) personnelWithNom: (NSString*) unNom andNumTel: (NSString*) unNumTel; // Même chose avec en plus le numTel + (int) dernierNumPers; // Retourne le dernier numéro attribué qui sera une variable globale, // nous en verrons plus tard - (id) initWithNom: (NSString*) unNom andNumTel: (NSString*) unNumTel; // Initialisation sans allocation - (int) numPers; // Retourne le numéro du Personnel - (NSString*) nomPers; // Retourne son nom - (NSString*) numTel; // Retourne son numéro de tel - (void) setNumTel: (NSString*) unNumTel; // Au cas où il faille attribuer le numéro de tel voire le changer - (NSString*) description; // Nous sommes en mode commande, cette méthode permettra l'affichage dans ce mode. - (void) dealloc; // Permet la désallocation.

Vous pouvez remarquer qu'il y en a un certain nombre . Et encore, j'ai supprimé une méthode dont on n'a pas encore l'utilité pour l'instant.

- Partie Modifiée : la méthode "string" a été remplacée par la méthode "description", les explications sont dans l'implémentation de cette méthode. -

Enfin, voilà pour l'interface ! Tant de texte pour si peu de code écrit ! Ne vous inquiétez pas, vous allez pouvoir taper du code après, lors de la définition de l'implémentation des méthodes. Donc en conclusion, l'interface d'une classe définit les attributs de celle-ci ainsi que le nom de ses méthodes avec leur paramètre et type retourné.

 

Les Messages ou "Parlez-vous Objective-C ?"

Héhé ! Question Vocabulaire, l'ObjC est innovant, puisque pour les objets n'appellent pas des méthodes d'aures objets, non non non ! Ils s'envoient des "messages" ! C'est amusant puisque ça permet de voir les objets comme des entités totalement indépendantes, l'un n'est pas l'esclave de l'autre, et ces objets discutent entre eux, s'entre-aide en quelque sorte, on peut y voir là l'extension du concept de la communication inter-processus d'Unix qui a du plaire à Steve Jobs , c'est-à-dire une architecture horizontale, tous au même niveau pour atteindre un seul but !

Enfin en tout cas, c'est comme ça que je vois ce concept de messgaes, qui n'a pas d'autres intérêts, à mon avis, de dépeindre cette vision. Et oui puisque maintenant les données sont encapsulées, et donc inaccessibles de l'extérieur, il faut, pour arriver à fonctionner, faire communiquer tous ces objets. Alors les messages ont une syntaxe spéciale, vous avez déjà pu l'entrevoir plus tôt, rien qu'avec le programme "Hello, World!" offert par Xcode.
Voici la syntaxe : [receveur message]

Alors, le "receveur" est l'objet ou la classe, car il est possible d'envoyer des messages à des classes, qui doit recevoir le "message". Et le message, c'est en fait la méthode que vous souhaitez appeler avec les valeurs de ses paramètres. Alors, on va reprendre les méthodes de notre classe et voir des exemple de message et leurs utilisations dans un programme :

Par exemple, je veux connaître le numéro de personnel de l'objet : "Personnel *toto;", alors je vous rappelle la méthode rrenvoie un entier... Donc ce petit texte entre crochet sera "égal" à cette valeur, voici un petit code qui récupère le numéro de Personnel :
int numero = [toto numPers];

Alors là, vous voyez, "toto" est bien un pointeur sur un Personnel, mais cette étoile n'est nécessaire qu'à la déclaration ou dans la déclaration des paramètres des méthodes. C'es tun pointeur qui doit se trouver en tant que receveur ! Et à côté le message, qui ressemble étrangement à notre méthode de tout à l'heure...

Maintenant regardons une méthode avec des paramètres, je veux changer le numéro de téléphone de "toto" :
[toto setNumTel:@"00 34 5 00 00 00 01"];

Alors, on voit déjà deux trucs, cette méthode ne renvoie rien ( void ), donc pas besoin de récupération de valeurs. Ensuite on voit ce : "@"..."", ça c'est une chaîne de caractères style d'Objective-C, cela représente une chaîne NSString tout simplement. Si vous ne mettez pas le "@" ce sera une chaîne typiquement C.

Il est possible d'encapsuler dans un message dans un autre, c'est possible pour les méthodes qui renvoient quelque chose, c'est même très souvent utiliser, surotut lors de l'initialisation des nouveaux objets. Par exemple, on va initialiser notre "toto" à l'aide de notre méthode "init", voici la technique la plus usité et surtout celle que je vous conseille largement d'utilisé car elle permet d'éviter des erreurs :
Personnel *toto = [[Personnel alloc] initWithNom:@"toto" andNumTel:@"00 34 5 00 00 00 01"];

Alors là, vous voyez beaucoup de choses en une seule ligne... Que fais-je là-dessus ? Trois choses, dans l'ordre d'exécution :

• La déclaration de la variable toto.
• L'allocation de la mémoire pour cette variable
• L'initialisation de l'objet.

Plus haut je vous ai dit qu'on pouvait envoyer des messages à des méthodes, déjà on a définit des méthodes dans ce but, ce sont les méthodes dont la déclaration commence par un "+". Mais là, j'envoie à la classe Personnel, le message "alloc", on n'a pourtant rien définit de tel ! En fait, vous entrevoyez la notion d'héritage, cette méthode n'est pas définie dans Personnel, mais dans NSObject, classe contenant beaucoup de méthode très utile, cette méthode renvoie un pointeur sur un Personnel complètement anarchique, si vous faites des actions là-dessus ça va vous faire mal à la gueule, d'où l'intérêt de ne faire qu'une instruction. L'initialisation se fait juste après sur ce pointeur et renvoie à nouveau le pointeur sur l'objet, notre petite variable toto récupère tout simplement cette adresse et devient en quelque sorte cet objet. Et c'est à partir de cette simple ligne que l'on peut exécuter les deux précédents messages.

Alors vous voyez c'est assez simple. Pour l'instant je ne vous ai montré que des paramètres écrit "à la volée", c'est-à-dire écrite directement là où elle est demandée. Mais lorsqu'il s'agit de mettre en paramètre des objets quelconques déjà définit depuis longtemps, et bien il suffit de remplacer le "@""" par le nom de la variable.

Voilà, j'espère que ce concept, relativement simple, et bien compris. Maintenant, nous pouvons attaquer la définition de l'implémentation de nos méthodes !