[ActionScript] L'héritage avancé - InfographiK

**Smike** · #1 (**permalink**) 04/04/2007, 13h01

Comprendre l'héritage :
Bien que cette notion ne soit pas totalement nouvelle, elle mérite quelques explications. L'héritage en POO est directement lié à la hiérarchie des classes en ActionScript 2.0. Des classes peuvent être définies comme étant des sous-classes d'autres super-classe.

Le but étant que cette sous-classe va automatiquement hériter des propriétés et des méthodes de sa classe mère, et ceci sans les redéfinir. Reprenons l'exemple de notre classe Voiture. Notre voiture est un type de véhicule comme un train, un bateau ou un avion. Bien que ces types de véhicules soient bien distincts, ils partagent certaines caractéristiques communues. Par exemple, une propriété communue pourrait être le nombre de passager du véhicule, la vitesse de déplacemment. Chaque véhicule peut se déplacer, à une vitesse donnée... Si on désirait créer notre classe Vehicule, cette classe contiendrait toutes ces caractéristiques communues à notre voiture, avion, ... Donc on pourra définir les propriétés et méthode à un seul endroit, plutot que de les définir dans toutes les classes (Voiture, Avion, ..)

Mise en place de l'héritage :
Par la suite, nous allons utiliser les termes de classe-fille (ou subclass) et de la classe-mère (ou superclass). La création de classe-fille est identique à la création d'une classe. La seule chose à rajouter, c'est spécifié à Flash, quelle classe est la superclass de cette subclass. Pour ceci, on va utiliser le mot-clé extends lors de la définition de nos classes.
Un exemple général, representant une classe héritant d'une superclass :

ActionScript Code:

class Subclass extends Superclass
{
//Définition
}

On dit ici que la classe Subclass hérite de la classe Superclass.
Dans notre exemple de la voiture, on aurait ceci :

ActionScript Code:

class Voiture extends Vehicule
{
 
}

En spécifiant que la classe Voiture hérite de la classe Vehicule, toutes les propriétés et méthodes de la classe Vehicule seront disponibles depuis la classe Voiture.

Appeler ou redéfinir les méthodes de la classe mère :
Au moment de l'héritage, il arrive que la fonction de la classe mère suffise parfaitement pour la classe fille. Mais on peut très bien redéfinir une methode de la classe mère, dans la classe fille. Cette technique s'apelle Overriding.

De cette façon, la méthode peut être rédéfinie pour réaliser des traitements spécifiques à la classe fille. Prenons un exemple, voici une fonction display(), qui va uniquement afficher un message. Dans notre classe Vehicule (donc la classe mère), elle peut définie de cette façon :

ActionScript Code:

public function display():Void {
trace("Methode de la Classe Mere");
}

Si on veut redéfinir cette méthode dans la classe fille (donc Voiture), on implémente à nouveau la méthode display() :

ActionScript Code:

public function display():Void {
trace("Methode de la Classe Fille");
}

Parfois, il est nécessaire de redéfinir entièrement une méthode de la Superclass, mais aussi quelquefois, de reféfinir une méthode tout en appelant la méthode la classe Mère. Dans notre exemple, on voudrait appeler la methode de la classe mère et réaliser un traitement spécifique sur la classe fille. Pour cela, nous allons utiliser le mot-clé super qui permet d'accéder à la Superclass. La définition de notre méthode display() deviendrait donc :

ActionScript Code:

public function display():Void {
super.display();
trace("Methode de la Classe Fille");
}

En réalisant un test dans un fla, on obtiendrait une sortie :

Methode de la Classe Mère
Methode de la Classe Fille

Super permet aussi d'appeler le constructeur de la classe mère. De ce fait, il est tout à fait possible d'appeler le contructeur avec des paramètres spécifiques. Pour se faire, on fera un simple appel de :

ActionScript Code:

super();

Classe Vehicule et Voiture :
Nous allons créer notre super classe Vehicule. Comme nous l'avons vu auparavant, notre classe mère doit contenir des caractéristiques communues aux types de véhicules que nous voulons créer. Car pour bien comprendre l'héritage, il ne faudrait pas se dire qu'il n'y aura pas que la classe Voiture, mais aussi la classe Avion, Bateau, ... Voici la liste (exhaustive) des propriétés, méthodes que nous allons définir.

Propriété : Nombre de passager (chaque type de véhicule contient n passagers)
Propriété : Kilomètre (chaque type de véhicule possède des kilomètres)
Propriété : Fabricant
Propriété : Année
Méthode : déplacer (chaque véhicule peut se déplacer à une vitesse donnée).

En ActionScript 2.0, l'implémentation de cette classe serait :

ActionScript Code:

class com.dossier.Vehicule
{
 
private var _sFabricant:String;
private var _nKilometres:Number;
private var _nPassager:Number;
private var _nInterval:Number;
 
function Vehicule(sFabricant:String, nKilometre:Number, nPassager:Number) {
_sFabricant = sFabricant;
_nPassager = nPassager;
kilometre = nKilometre;
}
 
 
public function get fabricant():String {
return _sFabricant;
}
 
public function get passager():String {
return _nPassager;
}
 
public function get kilometre():Number {
return _nKilometres;
}
 
public function set kilometre(nKilometres:Number):Void {
if(nKilometres >= 0) {
_nKilometres = nKilometres;
}
else {
_nKilometres = 0;
}
}
 
public function deplacer(nKMH:Number):Void {
if(nKMH == null || nKMH == 0) {
clearInterval(_nIntervalle);
}
else {
_nIntervalle = setInterval(this, "ajoutKilometre", 1000, nKMH);
}
}
 
private function ajoutKilometre(nKMH:Number):Void {
_nKilometres += nKMH;
}
}

Définissons maintenant notre classe Voiture. Une voiture est un véhicule. Ce véhicule à des particularités. Par exemple, on va définir un modèle de voiture, ainsi qu'une année de mise en circulation.
Les autres propriétés seront héritées de la classe mère :

ActionScript Code:

class com.dossier.Voiture extends Vehicule
{
 
private var _sModele:String;
private var _nAnnee:Number;
 
function Voiture(sFabricant:String, nKilometre:Number, nPassager:Number, sModele:String, nAnnee:Number) {
super(sFabricant, nKilometre, nPassager);
_sModele = sModele;
annee = nAnnee;
}
 
public function get modele():String {
return _sModele;
}
 
public function get annee():Number {
return _nAnnee;
}
 
public function set annee(nAnnee:Number):Void {
if (nAnnee >= 1886) {
_nAnnee = nAnnee;
}
else {
_nAnnee = 1886;
}
}
 
public function conduire(nKMH:Number):Void {
deplacer(nKMH);
}
 
}

On observe bien l'utilisation de la classe mère, au niveau du contructeur et au niveau de la méthode conduire. Testons ces classes dans un fichier fla. Créer un document fla, vérfier bien le classpath de votre application, et mettez ce code dans l'image 1 de votre timeline.

ActionScript Code:

import com.dossier.*;
function displayKilometrage(voitureObj:Voiture):Void {
Trace(voitureObj.kilometre);
}
var voiture:Voiture = new Voiture("SEAT", 55000, 5, "LEON", 2001);
voiture.conduire(50);
setInterval(displayKilometrage, 1000, voiture);

Source : Adddvance.net

Outils de la discussion
Afficher une version imprimable Envoyer un lien vers cette page par email