|
Un objet est une instance
de classe, la création d'objets s'appelle donc l'instanciation.
Cette instanciation se fait grâce à l'opérateur
new suivi du nom de la classe à instancier et
de parenthèses contenant les paramètres d'instanciation
(parenthèses vides s'il n'y a pas de paramètres).
Soit la classe Personne suivante:
class Personne{ int age;
} L'instanciation de cette classe
(rudimentaire et actuellement inutile...) se fait de la façon
suivante:
new Personne();
Dans l'état actuel
des choses (la simple création d'un objet avec le mot
clé new), l'objet nouvellement créé
est tout simplement inutilisable, car une fois que l'on a
créé l'objet il n'y a aucune façon de
le désigner (Personne représente le nom
de la classe et non celui d'une de ces instanciations).
Il est heureusement possible
d'identifier chaque objet par un nom grâce à un élément appelé
référence (en anglais handle, littéralement
poignée). On ne peut toutefois pas dire qu'un handle
soit le nom d'un objet, étant donné qu'un objet
peut posséder plusieurs handles (un handle
ne peut par contre désigner qu'un seul objet). Le concept
des handles est très proche de celui des pointeurs
en langage C/C++, il est toutefois beaucoup plus simple à
comprendre et à mettre en oeuvre.
Pour créer une référence
d'objet il suffit de faire précéder le nom que
l'on donne à un objet par le nom de la classe que l'on
instancie, par exemple une référence de l'objet
Toto, instance de la classe Personne, peut être défini
de la manière suivante:
Personne Toto;
La référence Toto ne
pointe pour l'instant vers aucun objet. Pour ce faire, il suffit
de l'initialiser, c'est-à-dire en réalité
de lui affecter le résultat de la création de
l'objet renvoyé par l'opérateur new. Avec
l'exemple précédent cela pourrait s'écrire
de la façon suivante:
Personne Toto;
Toto = new Personne();
|
L'affectation de l'opérateur new
à la référence ne signifie en aucun
cas que l'on stocke l'objet dans la référence,
cela indique que la référence pointe vers
l'objet nouvellement créé! |
Les deux lignes précédentes
peuvent être regroupées en un seul de la façon
suivante:
Personne Toto = new Personne();
L'accès aux données
membres d'un objet se fait grâce au nom de la référence
vers l'objet, suivi d'un point puis du nom de la donnée
membre. Par exemple:
Nom_du_handle.Nom_de_la_donnee_membre = Valeur;
Si jamais la donnée membre est une
référence vers un autre objet, on peut accéder
à ses données membres par l'intermédiaire
de l'objet en cours:
Nom_du_handle.Nom_donnee_membre_objet.Nom_donnee_membre_de_l_autre_objet = Valeur;
L'accès aux méthodes
d'un objet se fait comme pour l'accès aux données
membres, c'est-à-dire par un point. La méthode
est suivie de parenthèses, contenant les paramètres,
si il y'en a. L'accès à une fonction membre
se fait donc de la façon suivante:
Nom_du_handle.Nom_donnee_fonction_membre(parametre1,parametre2,...);
Le mot clé this
permet de désigner l'objet dans lequel on se trouve,
c'est-à-dire que lorsque l'on désire faire référence
dans une fonction membre à l'objet dans lequel elle
se trouve, on utilise this.
L'objet courant this
est en réalité une variable système qui
permet de désigner l'objet courant. Cette variable
est passée en tant que paramètre caché
de chaque fonction membre.
Ainsi, lorsque l'on désire
accéder à une donnée membre d'un objet
à partir d'une fonction membre du même objet,
il suffit de faire précéder le nom de la donnée
membre par this.. Par exemple:
class Toto{
int age;
char sexe[16];
void DefineTotoAge(int age){
this.age = age;
}
}
En réalité, lorsque l'on donne
des noms différents aux données membres et aux
variables utilisées dans les fonctions membres, la variable
this est implicite, cela signifie que l'on est pas obligé
de mettre this. devant chaque donnée membre.
Dans le cas ou l'on désire
une fonction membre qui retourne un pointeur vers l'objet
dans lequel elle se trouve, la variable this est indispensable:
class Toto{
int age;
char sexe[16];
void DefineTotoAge(int age){
this.age = age;
}
Toto * RetourneToto(){
return this;
}
}
 
|
