|
 |
|
 |
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();
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;
}
}
|
