L'héritage est une relation entre deux classes ou plus, où une classe hérite des propriétés et des méthodes définies dans une autre classe. En terme pratique, l'héritage permet qu'une classe emprunte le code d'une autre classe.
Mais l'héritage est plus qu'un simple moyen de réutiliser du code, c'est un outil pour conceptualiser et modéliser. Comme en génétique on hérite des traits de nos parents, en POO l'héritage permet de créer des classes qui ressemble à une autre, tout en y ajoutant des particularité unique.
Voyons un exemple simple afin de montrer la syntaxe de base.
class Une {
public var a:Number = 10;
public function x():Void {
trace("la methode x()");
}
}
/* On créera une instance de Un, on invoquera la méthode x()
et on accèdera à la propriété p comme ceci:
*/
var uneInstance:Une = new Une();
uneInstance.x(); // Affiche: la methode x()
trace(uneInstance.p); // Affiche: 10
On créera maintenant une deuxième classe, Deux, qui héritera de la méthode x() et de la propriété p de la classe Une. On utilise le terme extends pour créer la filiation entre deux classes.
class Deux extends Une {
// Aucune methode ni propriete
}
/* On peut maintenant accéder à la methode x() et la propriete p
comme ceci:
*/
var deuxInstance:Deux = new Deux();
deuxInstance.x(); // Affiche: la methode x()
trace(deuxInstance.p); // Affiche: 10
Lorsque que deuxInstance.x() est invoqué, l'interpréteur du code regarde d'abord dans la class Deux pour une méthode nommée x(). Comme il ne trouve rien dans la class Deux, il regarde ensuite dans la superclasse de Deux, la classe Une. Alors, il trouve la méthode x() et l'exécute.
Ainsi, l'héritage permet, pour une sous-classe, la réutilisation des méthodes et des propriétés de sa superclasse, l'extension où une sous-classe ajoute ses propres méthodes et propriétés, mais également la redéfinition, par la sous-classe, de méthodes et de propriétés de sa superclasse. La redéfinition permet d'ajouter, d'augmenter ou même d'annuler les comportements d'origine de la classe.
Pour écraser - ou redéfinir (on parle d'overriding en anglais) - une méthode d'instance, il suffit de fournir, dans la sous-classe, une définition de méthode portant le même nom que celle de la superclasse. Dans l'exemple suivant, B est la sous-classe de A et la méthode B.x() écrase la méthode A.x():
class A {
// on declare une methode d'instance dans la superclasse
public function x ():Void {
trace("La methode A.x()");
}
}
// La classe B est un sous-classe de A
class B extends A {
// on ecrase la methode la superclasse
public function x():Void {
trace("La mehode B.x()");
}
}
Quand x() est invoqué sur une instance de la classe A, l'interpréteur utilise la définition de la classe A. Mais si x() est invoqué sur une instance de la classe B, l'interpréteur utilise la définition de la classe B au lieu de celle de la classe A.
La redéfinition fonctionne de la même façon pour les propriétés. L'important est de remplacer une propriété d'instance par une autre propriété d'instance, une méthode de classe par une autre méthode de classe, et ainsi de suite.
On gardera toujours en tête les principes suivants:
Dans ActionScript, tous les objets sont construits sur ce modèle d'héritage. En fait, tous les objets (intégrés ou personnalisés) héritent directement ou indirectement de la racine de tous les objets, l'objet Object. La classe Object définit certaines méthodes que toutes les classes utilisent, comme la méthode Object.toString(), qui retourne la représentation d'un objet sous la forme d'une chaîne de caractères.
La fonction constructeur permet d'initialiser les instances d'une classe:
Lorque l'on crée une sous-classe, celle-ci peut aussi définir sa propre fonction constructeur. La fonction constructeur d'une sous-classe:
La fonction constructeur d'une sous-classe se doit d'invoquer le constructeur de la superclasse avec le mot-clé super, comme première instruction de la fonction. Si l'instruction super() n'apparait pas, le compilateur ajoute automatiquement un appel au constructeur de la superclasse.
class A {
public function A () {
}
}
class B extends A {
// Constructeur de la sous-classe
public function B () {
// appel explicite au constructeur de la superclasse
super();
}
}
La sous-classe peut aussi passer des paramètres au constructeur de la superclasse, afin de modifier la façon dont la superclasse va instancier des objets.
Comme on peut créer des sous-classes de nos propres classe, on peut aussi créer des sous-classes des classes intégrées à ActionScript. Cela nous permet d'ajouter ou de modifier les fonctionnalités d'une classe ActionScript.
Dans l'exemple suivant, nous ajoutons une méthode timediff() qui va retourner le temps, en millisecondes, entre deux instances de la classe Date. Une sous-classe DateDeluxe est créée.
class DateDeluxe extends Date {
public function DateDeluxe (year:Number, month:Number, date:Number
hour:Number, min:Number,
sec:Number, ms:Number)
{
super(year, month, date, hour, min, sec, ms);
}
public function timediff (d:Date):Number {
return Math.abs(this.getTime() - d.getTime());
}
}
Cette nouvelle classe s'utilise comme suit:
// Fait une instance de DateDeluxe
var d1:DateDeluxe = new DateDeluxe();
// Passe le temps un peu
for (var i:Number; i < 10000; i++) {
// La li la la...
}
// Fai une autre instance de DateDeluxe
var d2:DateDeluxe = new DateDeluxe();
// Affiche le temps ecoule entre d1 et d2
trace(d1.timediff(d2));