Notions d'héritage

Une occurence accède aux propriétés et aux méthodes de la classe à partir de laquelle elle est définie. Si la classe parent de cette occurence est elle même une occurence d'une autre classe, la première occurence hérite dans un premier temps des propriétés et occurence de la classe mère puis de la classe à partir de la quelle elle est définie. Si des méthodes ou propriétés sont redéfinies dans la classe enfant ou même dans l'objet lui même, ce sont elles qui seront prises en compte lors de leur execution ou utilisation. Exemple:

monNombre= new Number();

monNombre accède aux méthodes et propriétés de la classe Number et hérite des méthodes et propriétés de la classe Object (qui est une classe mère de la classe Number

Exemples multiples

L'exemple ci-dessous peut-être copié collé tel quel dans le panneau AS :

// création d'un nouvelle méthode à l'objet Object
Object.prototype.fonctionObj= function() {
trace("je suis une méthode de Object");
}

// création des fonctions constructeur des classes clasA, clasB et clasC
clasA= function () {
this._maClasse="clasA";
};
clasB= function () {
this._maClasse="clasB";
};
clasC= function () {
this._maClasse="clasC";
};

// création des liens d'héritage entre les classes ClasC et clasB
clasC.prototype=new clasB();

/* de cette facon, les occurences de clasC accèderont aux méthodes contenues dans le prototype de clasB
clasA et clasB sont par défaut des occurences de la classe object (comme toutes les classes prédéfinies ou personnelles).
les occurences de la clasA et clasB accèderont aux méthodes contenues dans le prototype de Object
Grace au liens d'héritage les occurences de clasC accèderont aux méthodes de clasB et de Object */

// ajout de méthodes à chacune des trois classes
clasA.prototype.fonctionA= function() {
trace ("je suis une méthode de clasA");
}

clasB.prototype.fonctionB= function() {
trace ("je suis une méthode de clasB");
}

clasC.prototype.fonctionC= function() {
trace ("je suis une méthode de clasC");
}

// création des occurences occuA et occuB
occuA = new clasA();
occuC = new clasC();

// création d'une méthode de l'occurence occuC
occuC.fctOccu = function() {
trace("je suis une méthode de l'occurence occuC")
}

// teste des liens d'héritage de occuC
occuC.fctOccu(); // renvoie "je suis une méthode de l'occurence occuC"
occuC.fonctionC(); // renvoie "je suis une méthode de clasC"
occuC.fonctionB(); // renvoie "je suis une méthode de clasB"
occuC.fonctionObj(); // renvoie "je suis une méthode de Object"
occuC.fonctionA(); // ne renvoie rien

/* on constate bien que occuC hérite de l'ensemble des méthodes de la chaine d'héritage formée par les
classes Object>clasB>clasC mais pas de la classe clasA qui n'en fait pas partie */

trace("======================");

// teste des liens d'héritage de occuA
occuA.fctOccu(); // ne renvoie rien
occuA.fonctionC(); // ne renvoie rien
occuA.fonctionB(); // ne renvoie rien
occuA.fonctionA(); // renvoie "je suis une méthode de clasA"
occuC.fonctionObj(); // renvoie "je suis une méthode de Object"
/* on constate bien que occuA hérite de l'ensemble des méthodes de la chaine d'héritage formée
par les classes Object>clasA mais pas de clasB et clasC qui n'en font pas partie */

// Fonctionnement de l'héritage
// création de la méthode heritage() de la classe Object (1)
Object.prototype.heritage= function () {
trace ("méthode de Object");
}

trace("======================");

occuC.heritage(); // renvoie "méthode de Object"

/* occuC appelle une méthode, dans un premier temps il cherche si la fonction est une de ces fonctions
s'il ne la trouve pas, il regarde dans sa propriété __proto__, étant une occurence de clasC, __proto__
pointe vers le prototype de clasC il ne trouve pas de méthode héritage() il poursuit en remontant par la chaine de l'héritage dans
le prototype de clasB, toujours rien, il remonte dans le prototype de Object et trouve la méthode et l'execute */

// création de la méthode heritage() de la classe clasB (2)
clasB.prototype.heritage= function () {
trace ("méthode de clasB");
}

//NB: la méthode heritage de Object existe

trace("======================");

occuC.heritage(); // renvoie "méthode de clasB"

/* occuC appelle la méthode, reproduit la démarche précédente et trouve la méthode dans le prototype de clasB
c'est cette méthode qui s'executera et la méthode du même nom contenue dans le prototype de Object sera ignorée.
Poursuivez avec les étapes (3) et (4) et constatez que c'est toujours la méthode la plus "proche" de l'occurence
dans l'arbre d'héritage qui sera executée et les autres ignorées. */

trace("======================");

/* modification de l'héritage (5)
on a vu plus haut comment construire le chainage d'héritage entre les classes au moyen de prototype.
les occurences possèdent pour leur part une propriété __proto__ qui est un pointeur vers le prototype de leur classe
cette propriété est modifiable et permet de changer l'arbre d'héritage d'une occurence en écrivant: */

occuC.__proto__=clasA.prototype;

/* le __proto__ de occuC pointe maintenant vers le prototype de clasA et occuC n'hérite plus que des méthodes
de clasA et Object: */

// teste des liens d'héritage de occuB
occuC.fctOccu(); // renvoie "je suis une méthode de l'occurence occuC"
occuC.fonctionC(); // ne renvoie rien
occuC.fonctionB(); // ne renvoie rien
occuC.fonctionA(); // renvoie "je suis une méthode de clasA"
occuC.fonctionObj(); // renvoie "je suis une méthode de Object"