Actionscript 2.0 pour les utilisateurs d'Actionscript 1.0


Article écrit par Joey Lott de www.person13.com
Traduit par petepx aka Francis Bourre

"Special thanks go to Francis for his fantastic translation of this article and making it accessible to the French Flash community." Joey Lott


Comme promis dans la 1ère partie de cet article, nous allons examiner la nouvelle syntaxe concernant les classes en ActionScript 2.0. Avant de commencer, si vous avez des lacunes à propos des concepts orientés objet dans Flash, vous pouvez commencer par lire ces 2 articles :

http://www.oreillynet.com/pub/a/javascript/2003/08/12/actionscriptckbk.html
http://www.oreillynet.com/pub/a/javascript/2003/08/19/actionscriptckbk.html

Les deux articles traitent des concepts orientés objet et de la création de classes en ActionScript 1.0. Vous n’avez nul besoin de mémoriser tous les détails des techniques ActionScript 1.0, ces articles vous donneront une bonne introduction sur le concept des classes et objets en général et une fois que vous aurez acquis ces connaissances de bases, cet article prendra tout son sens.


ActionScript 2.0 Structure d’une classe

Je serai tenté de commencer par un comparatif entre les structures d’une classe ActionScript 1.0 et celles d’une classe ActionScript 2.0, mais j’éviterai ce piège pour ne pas semer le trouble dans les esprits. Il est évident que la structure d’une classe en ActionScript 2.0 est fondamentalement différente de celle d’une classe en ActionScript 1.0. Si vous avez quelques connaissances concernant le sujet en Java, C#, VB ou PHP, vous allez être comblés par la nouvelle structure formelle d’ActionScript.
Si votre seule expérience dans le domaine se limite à ActionScript 1.0, ne paniquez pas. Vous découvrirez que même si la syntaxe d’ActionScript 2.0 est très différente, elle est beaucoup plus intuitive. Après une semaine de pratique en ActionScript 2.0, vous vous demanderez même comment vous avez pu travailler avec ActionScript 1.0.

Pour commencer, je vais mettre en lumière quelques éléments clés de la nouvelle structure et syntaxe concernant les classes, puis après nous passerons aux cas pratiques.

Quelques principes de base :

  • Une classe en ActionScript 2.0 doit être définie à l’intérieur d’un fichier .as. Il ne peut y avoir qu’une seule classe par fichier.
  • Une classe en ActionScript 2.0 est déclarée en utilisant le nouveau mot clé class suivi par le nom de la classe et ensuite le corps de la classe entouré de deux accolades.
    Par exemple :

 
ActionScript:

class Voiture {
        // Définition de la classe
}

  • Les classes en ActionScript 2.0 peuvent être organisées à l’intérieur de packages. ActionScript 2.0 utilise le mot clé import pour importer un package entier ou choisir une classe à l’intérieur d’un package.
  • Les membres d’une classe en ActionScript 2.0 peuvent être déclarés publiques, privés ou statiques.
  • Une classe en ActionScript 2.0 peut hériter d’une autre classe en utilisant le mot clé extends dans la déclaration de celle-ci.
  • Les classes en ActionScript 2.0 peuvent implémenter des interfaces.
    • Si la description ci-dessus vous a paru hermétique ou voir totalement incompréhensible, gardez le fil. En effet, je vais m’employer tout au long de ce chapitre à vous expliquer chacun des principes de base plus en détail illustrés par des exemples concrets que vous pourrez tester vous-même (en supposant bien sûr que vous avez une copie de Flash MX 2004 ou Flash MX Professional 2004.)


Définition des fichiers classes en ActionScript

Si vous n’êtes pas familier avec certains langages comme Java ou C#, organiser des classes dans leurs propres fichiers sera probablement pour vous un concept totalement nouveau, particulièrement si vous aviez l’habitude de travailler en ActionScript 1.0 où vous pouviez définir plusieurs classes à l’intérieur d’un même fichier .as ou d’un fichier .fla.

Il existe de nombreuses raisons pour lesquelles il est plus intéressant de ranger chacune de vos classes à l’intérieur d’un fichier .as unique et externe.
L’avantage principal est, bien sûr, une meilleure organisation. Il est plus facile de ranger, placer, traiter, et distribuer vos classes lorsque celles-ci sont bien organisées. Si vous définissez vos classes n’importe où, vous serez rapidement submergé par le désordre. Bien sûr, si vous travaillez seulement avec deux ou trois classes, vous ne sentirez pas vraiment l’intérêt.
Deuxième avantage, ActionScript 2.0 enrichit ActionScript d’un nouveau concept, les développeurs peuvent maintenant créer et partager des librairies de classes offrant de nouvelles fonctionnalités pour des développements futurs et annexes. Plutôt que de « réinventer la roue à chaque fois », les développeurs peuvent construire leurs propres applications et en même temps contribuer à l’avancement des projets de la communauté Flash. Vous pouvez déjà dés maintenant apprécier comment Macromedia a ouvert la voie déjà avec son set de classes standards que vous trouverez dans le répertoire First Run/Classes (et sous répertoires) de votre installation de FLASH MX 2004.

Donc pour résumer, contrairement aux classes ActionScript 1.0, toutes les classes ActionScript 2.0 doivent être sauvées dans des fichiers .as externes. De plus, ces fichiers doivent être sauvés avec le même nom que celui de la classe qu’il abrite. Par exemple, si la classe s’appelle Voiture, le fichier doit se nommer Voiture.as.


Travailler avec des Packages

Les fichiers de classe doivent être organisés dans des packages. Si vous n’êtes pas familier avec les packages (également appelés namespaces dans le monde .NET), sachez qu’il s’agit juste d’une manière simple d’organiser vos classes. Il y a deux aspects dans la notion de package.

Premièrement, la définition de la classe doit spécifier le package dans sa déclaration. Nous verrons cela plus en détail dans la prochaine section.
Deuxièmement, le fichier .as doit être sauvé dans un répertoire correspondant. Par exemple, si le package d’une classe est com.person13 alors le fichier .as de cette classe doit être sauvé dans la structure de répertoire com/person13.

Travailler avec des packages présente deux avantages primordiaux.
Le premier est la possibilité d’organiser vos fichiers de manière à les retrouver rapidement. Par exemple, si vous regardez dans le set de classes de Flash MX 2004 (dans le répertoire First Run/Classes) vous verrez que plusieurs classes pour les composants UI sont organisées à l’intérieur du package mx.controls, et sont pour cela sauvés dans le répertoire mx/controls.
Le second est de pouvoir éviter les conflits de nom. Vous ne pouvez pas avoir deux classes avec le même nom dans le même package pour la pure et bonne raison que Flash ne saurait pas laquelle vous voulez utiliser. Donc, si vous n’utilisez pas de package et sauvez toutes vos classes dans le même répertoire, vous rencontrerez probablement de nombreux problèmes. Bien sûr, si vous écrivez vous-même toutes vos classes, vous pouvez toujours vous assurer de donner à chaque classe un nom unique. Mais le jour où vous téléchargerez et installerez des classes élaborées par d’autres développeurs, vous n’aurez pas les mêmes garanties. Donc, pensez toujours à ranger vos classes dans des packages, cela vous permettra d’éviter d’éventuels conflits.
Par exemple, ranger la classe Voiture de person13 dans le package com.person13 et la classe Voiture de ejepo dans le package com.ejepo vous permettra d’éviter certaines erreurs.


Définir le répertoire racine de vos classes

Par défaut Flash regarde d’abord dans le répertoire First Run/Classes de Flash quand il cherche des fichiers classe. S’il ne trouve pas la classe spécifiée dans ce répertoire, il regarde ensuite dans le répertoire où le document Flash (ou ActionScript) est sauvé.

Le classpath est la liste des répertoires dans lequel Flash recherche les fichiers classe. Vous pouvez spécifier des répertoires additionnels à l’intérieur du classpath, et si vous le désirez, changer l’ordre dans lequel Flash parcourt ces répertoires. Pour éditer le classpath, choisissez Edit>Preferences, et sélectionnez l’onglet ActionScript. Cliquez ensuite sur ActionScript 2.0 Settings pour faire apparaître la fenêtre ActionScript Preferences. Utilisez le bouton + pour ajouter de nouveaux répertoires, le bouton – pour en effacer certains et les flèches pour changer l’ordre de parcours.


image 1: Définir le répertoire racine de vos classe


Comme vous pouvez le voir sur l’image 1, j’ai ajouté le répertoire D:\ActionScriptClasses dans mon classpath. Cela signifie que le troisième endroit où Flash ira chercher sera à présent D:\ActionScriptClasses. Par défaut, $(LocalData) emmène au répertoire First Run de l’installation de Flash.

Ajouter un répertoire au classpath est une intéressant pour plusieurs bonnes raisons :

  • Il est plus simple de parcourir un répertoire comme D:\ActionScriptClasses plutôt que de trouver celui dans lequel Flash organise ses classes par défaut.
  • Il est plus simple d’organiser vos fichiers si vous sauvez toutes vos classes dans un répertoire autre que celui dans lequel Flash met ses classes par défaut.


Comprendre les membres privés et publiques

Une classe est composée de membres – propriétés et méthodes.
A moins d’utiliser des dispositifs complexes ou non documentés d’ActionScript 1.0, tous les membres d’ ActionScript 1.0 sont publiques.
Quand nous disons d’un membre qu’il est publique, cela signifie que nous pouvons y accéder à partir de l’extérieur de la définition de la classe. Par exemple, si vous créez une classe Voiture avec une propriété nommée fabricant, et que nous pouvons accéder à celle-ci depuis une instance de la classe Voiture, on dit que la propriété est publique. Mais il arrive souvent qu’on ne veuille pas que les propriétés et méthodes d’une classe soient accessibles. Une classe peut avoir des propriétés et des variables qui sont utilisées seulement en interne, et n’ayant donc aucun intérêt à être exposé publiquement. Dans un cas pareil vous pouvez déclarer un membre privé.

Note: Si connaissez des langages comme Java ou C#, vous noterez qu’un membre privé en ActionScript 2.0 se comporte comme un membre protégé.

Pour déclarer un membre publique ou privé vous pouvez utiliser respectivement les mots clés public et private. Par exemple, la ligne qui suit déclare une propriété privée:

 
ActionScript:

class private var _nInterval:Number;


Par convention vous pouvez utiliser le caractère underscore comme premier caractère d’un nom de propriété privée afin de différencier les variables locales, valeurs en entrée et propriétés privées à l’intérieur d’une classe.

Nous étudierons plus tard comment déclarer des membres publiques et privés à l’aide d’un exemple concret. Ceci vous aidera à clarifier le sujet, et dans une prochaine section vous apprendrez à construire vous-même une classe qui utilise à la fois des membres privés et des membres publiques.

Note: La propriété par défaut sera publique si vous ne spécifiez rien.

Comprendre les membres statiques

Les membres statiques sont des membres auxquels on accède directement à partir de la classe, contrairement à une instance de celle-ci. Ce n’est pas un nouveau concept d’ActionScript 2.0. En effet, depuis Flash 5 vous avez vu eu l’occasion de voir des classes avec des membres statiques. Par exemple, la classe Math est entièrement constituée de membres statiques. Plutôt que de créer une instance de la classe Math et ensuite d’accéder aux propriétés et méthodes depuis une instance, vous accédez toujours aux propriétés et méthodes directement depuis celle-ci.

Exemple :

 
ActionScript:

trace(Math.cos(3.14));

On remarque que la méthode cos() est accessible directement depuis la classe Math, c’est donc une méthode statique.

Pour créer un membre statique dans une classe en ActionScript 2.0 on utilise le mot clé static dans la déclaration. Les membres statiques pourront être modifiés plus tard pour devenir soit publique soit privé, plus comme des membres non-statiques. Voici un exemple de déclaration de membre publique statique.
 
ActionScript:

public static var nomDeLaClasse = "Voiture";

 

Déclarer une classe

Examinons chacune des parties plus en détail.
Si nous étudions la structure d’une classe en des termes simplifiés, il existe 4 parties prendre en compte :

  • La déclaration de la classe constituée du mot clé class et du nom de la classe.
  • La déclaration des propriétés.
  • La déclaration du constructeur.
  • La déclaration des méthodes.

La déclaration de la classe
Pour déclarer une classe, vous devez utiliser le mot clé class suivit du nom de cette dernière. Ensuite, vous entourez la définition de la classe de deux accolades.

Par exemple: 
ActionScript:

class Voiture {
        // Définition de la classe
}


Si vous voulez mettre la classe dans un package, vous devrez indiquer le package comme partie intégrante du nom de votre classe dans la déclaration. On appelle une classe qui inclut le package le fullyqualified class name. Par exemple, si vous vouliez placer la classe Voiture dans le package com.person13, la déclaration de votre classe ressemblerait à ceci :

 
ActionScript:

class com.person13.Voiture {
        // Définition de la classe
}


Et bien sûr, quand vous placez une classe dans un package, vous devez être sûr de sauver le fichier contenant la classe dans le répertoire correspondant. Dans le cas de la classe com.person13.Voiture le fichier Voiture.as doit être sauvé à l’intérieur du répertoire com/person13 et le répertoire com doit être placé obligatoirement à l’intérieur du classpath de Flash (Par exemple, si votre classpath inclut D:\ActionScriptClasses, vous pourriez sauver votre fichier comme ceci D:\ActionScriptClasses\com\person13\Car.as.)

Déclaration des propriétés

Vous devez déclarer toutes les propriétés entre les deux accolades de la définition de votre classe. Vous devez aussi déclarer toutes les propriétés à l’extérieur des méthodes de celle-ci. Par convention vous devez déclarer toutes les propriétés au dessus de la définition de la classe.

Par exemple:

 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
		
        // Reste de la définition de la classe  
}

 

Déclaration du constructeur

Après avoir déclaré les propriétés à l’intérieur de la classe, vous devez ensuite déclarer le constructeur. Techniquement, si vous ne déclarez pas un constructeur explicitement, Flash créera un constructeur implicitement vide. Mais même si votre constructeur est vide, il est toujours préférable de le déclarer explicitement.

Rappelez-vous, le constructeur est une méthode spéciale qui partage le même nom que la classe. Le constructeur est utilisé pour créer une nouvelle instance de la classe. Le constructeur doit être déclaré juste comme une fonction classique, et bien qu’il puisse accepter des paramètres en entrée, il ne retournera pas de valeurs. Voici un exemple de la classe Voiture avec un constructeur en plus :

 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
		
        function Voiture(sFabricant, sModele, nAnnee, nKilometres) {
                _sFabricant = sFabricant;
                _sModele = sModele;
                _nAnnee = nAnnee;
                _nKilometres = nKilometres;
        }
		
        // Suite de la définition de la classe  
}

Contrairement à d’autres langages, vous ne pouvez pas avoir de constructeurs surchargés en ActionScript 2.0.

Déclaration des méthodes

Vous pouvez maintenant déclarer les méthodes de votre classe. Vous déclarer les méthodes comme des fonctions classiques, en utilisant le mot clé function et exactement la même syntaxe.
Rappelez-vous, une méthode est une fonction, la seule différence c’est qu’elle est associée à une classe. C’est parce que vous déclarez une fonction à l’intérieur d’une classe que Flash l’associe automatiquement à celle-ci. La seule différence entre une fonction standard et une méthode est la possibilité de déclarer une méthode publique, privée, ou statique si besoin est.

Voici l’exemple de la classe Voiture avec en plus cette fois-ci deux méthodes, l’une est publique, l’autre privée :

 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
        
        function Voiture(sFabricant, sModele, nAnnee, nKilometres) {
                _sFabricant = sFabricant;
                _sModele = sModele;
                _nAnnee = nAnnee;
                _nKilometres = nKilometres;
        }

        public function conduire(nKMH:Number):Void {
                if(nKMH == null || nKMH == 0) {
                        clearInterval(_nIntervalle);
                }
                else {
                        _nIntervalle = setInterval(this, "increment", 1000, nKMH);
                }
        }
        private function increment(nKMH:Number):Void {
                _nKilometres += nKMH;
        }
}

 

Se servir des méthodes Getter/Setter

Les méthodes getter et setter sont des méthodes spéciales qui sont accessibles à l’extérieur d’une classe comme des propriétés, mais qui sont définies à l’intérieur comme des méthodes.
L’un des avantages de l’utilisation des méthodes getter et setter est de pouvoir créer des membres qui fonctionnent comme des propriétés externes d’une classe, avec en plus la possibilité d’avoir une structure logique et sophistiquée.

Dans le cas de la classe Voiture, nous voulons nous assurer que la valeur de l’année de la voiture ne sera jamais inférieure à 1886 (l’année de construction de la première automobile) et que le nombre de kilomètres heure ne sera jamais inférieur à 0.

Voici les avantages proposés par les méthodes getter et setter :

  • Elles permettent de travailler avec des noms de propriétés comme _nKilometres à l’intérieur de la classe, mais aussi d’exposer cette valeur publiquement avec un nom de propriété plus conviviale comme kilometres.
  • Elles permettent de créer des propriétés en lecture seule ou en écriture seule.
  • Elles permettent de créer des propriétés virtuelles – propriétés qui ne correspondent à aucune propriétés à l’intérieur de la classe, mais qui sont générées par un mix de valeurs internes.

Une méthode getter ne doit jamais accepter de paramètre en entrée et doit toujours retourner une valeur en sortie. Voici la syntaxe de base pour une méthode getter :

 
ActionScript:

public function get nomDeLaProprieteExterne():leTypageEnSortie {
        // Définition de la méthode accompagnée d’un return.
}


Cette méthode peut comme les autres être modifiée avec les mots clés public et static , mais en aucun cas vous ne pouvez déclarer une méthode getter privée.

Voici l’exemple d’une simple méthode getter qui retourne la valeur _nKilometres en tant que propriété kilometres.

 
ActionScript:

public function get kilometres():Number {
        return _nKilometres;
}

La syntaxe de la méthode setter est similaire à celle de la méthode getter à l’exception près qu’elle doit toujours posséder une valeur en entrée, et ne jamais retourner de valeur en sortie, et pour finir utiliser le mot clé set à la place de get.

Voici la syntaxe de base :
 
ActionScript:

public function set kilometres(nKilometres:Number):Void {
        // Définition de la méthode accompagnée d’un return.
}

Comme pour les méthodes getter, vous pouvez définir les méthodes setter avec les mots clés public et static, mais jamais avec private. Voici un exemple d’une méthode setter qui assigne une nouvelle valeur à la propriété privée _nKilometres. Notez qu’elle vérifie si la valeur est supérieure ou égale à 0. Si ce n’est pas le cas, elle utilise la valeur par défaut 0.
 
ActionScript:

public function set kilometres(nKilometres:Number):Void {
        if(nKilometres >= 0) {
                _nKilometres = nKilometres;
        }
        else {
                _nKilometres = 0;
        }
}

 

Importer des Classes

Quand vous organisez vos classes dans des packages, vous avez l’obligation d’utiliser le nom de la classe fully-qualified quand vous la référencez.
Cela signifie que si vous avez créé com.person13.Voiture, pour créer une instance de la classe vous devrez faire comme ceci :

 
ActionScript:

var voiture:com.person13.Voiture = new com.person13.Voiture("Oldsmobile", "Alero", 2000, 43000);


Il existe cependant un raccourci. Vous pouvez utiliser l’instruction import pour dire à Flash quels packages et classes vous voulez utiliser. Flash déduira alors automatiquement le nom du package sans que vous n’ayez à lui spécifier de nouveau.

Voici un exemple qui importe la classe Voiture et construit ensuite une instance.

 
ActionScript:

import com.person13.Voiture;
var voiture:Voiture = new Voiture("Oldsmobile", "Alero", 2000, 43000);


Vous noterez que ce code est bien plus facile à lire. De plus, quand vous faites référence plusieurs fois de suite au même nom d’une classe, vous gagnez du temps pour l’écrire.

Vous pouvez aussi importer toutes vos classes depuis un package en utilisant le symbole wildcard *

Par exemple la ligne suivante importera toutes les classes du package com.person13.

 
ActionScript:

import com.person13.*;

 

Créer une Classe

Vous avez eu l’occasion tout au long de ce chapitre d’étudier les bases des classes en ActionScript 2.0, vous êtes fin prêt maintenant pour le grand saut : Créer votre propre classe.

Nous commencerons par créer une classe nommée Voiture. Lisez attentivement ce qui suit :

Créez un nouveau fichier ActionScript. Si vous utilisez Flash MX Professional 2004 vous pouvez utiliser l’éditeur de fichier ActionScript qui se trouve dans l’IDE. Sinon, rien ne vous empêche d’utiliser votre éditeur de texte préféré à la seule condition qu’il offre la possibilité de sauver une grande quantité de texte.

Les premières lignes de code que vous allez écrire à l’intérieur du fichier constituent la déclaration de la classe. Pour ce faire, vous devez utilisez le mot clé class suivi du nom de la classe plus deux accolades pour entourer la définition de celle-ci.

Commencez par ajouter le code suivant dans votre fichier :

 
ActionScript:

class Voiture {
}

Déclarez ensuite les cinq propriétés. Vous ferez de ces propriétés des propriétés privées. Les quatre premières sont assez explicites. La dernière servira à stocker l’ID pour une méthode interval que vous appliquerez à l’une des méthodes.


 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
		
  
}

Ensuite déclarez le constructeur.
Dans ce cas précis, nous ne mettrons que quatre valeurs en entrée et nous assignerons ces valeurs aux propriétés correspondantes. Vous noterez que deux propriétés déclarées dans la définition de la classe n’ont pas été assignées à l’intérieur du constructeur. C’est parce que ces propriétés seront définies plus tard avec la méthode setter. Nous privilégierons dans ce cas précis l’emploi de la méthode setter pour nous assurer qu’elles soient affectées sous la contrainte d’une certaine logique, et ainsi vérifier que les valeurs en entrée sont valides.
 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
		
        function Voiture(sFabricant, sModele, nAnnee, nKilometres) {
                _sFabricant = sFabricant;
                _sModele = sModele;
                _nAnnee = nAnnee;
                _nKilometres = nKilometres;
        }

}


Ensuite, déclarons les méthodes de notre classe. Nous allons commencer par créer une méthode publique nommée conduire(). Ensuite, nous rajouterons une méthode privée nommée increment() qui sera appelée par intervalle une fois la méthode conduire() exécutée avec un nombre valide de kilomètres par heure en entrée.

 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
        
        function Voiture(sFabricant, sModele, nAnnee, nKilometres) {
                _sFabricant = sFabricant;
                _sModele = sModele;
                _nAnnee = nAnnee;
                _nKilometres = nKilometres;
        }

        public function conduire(nKMH:Number):Void {
                if(nKMH == null || nKMH == 0) {
                        clearInterval(_nIntervalle);
                }
                else {
                        _nIntervalle = setInterval(this, "increment", 1000, nKMH);
                }
        }
        private function increment(nKMH:Number):Void {
                _nKilometres += nKMH;
        }
}

La dernière étape consiste à définir les différentes méthodes getter et setter comme indiqué ci-dessous :


 
ActionScript:

class com.person13.Voiture {
        
        private var _sFabricant:String;
        private var _sModele:String;
        private var _nAnnee:Number;
        private var _nKilometres:Number;
        private var _nIntervalle:Number;
        
        function Voiture(sFabricant, sModele, nAnnee, nKilometres) {
                _sFabricant = sFabricant;
                _sModele = sModele;
                _nAnnee = nAnnee;
                _nKilometres = nKilometres;
        }
        
        public function get fabricant():String {
                return _sFabricant;
        }
        
        public function get modele():String {
                return _sModele;
        }
        
        public function get annee():Number {
                return _nAnnee;
        }
        
        public function get kilometres():Number {
                return _nKilometres;
        }
        
        public function set kilometres(nKilometres:Number):Void {
                if(nKilometres >= 0) {
                        _nKilometres = nKilometres;
                }
                else {
                        _nKilometres = 0;
                }
        }
        
        public function set annee(nAnnee:Number):Void {
                if (nAnnee >= 1886) {
                        _nAnnee = nAnnee;
                }
                else {
                        _nAnnee = 1886;
                }
        }
        
        public function conduire(nKMH:Number):Void {
                if(nKMH == null || nKMH == 0) {
                        clearInterval(_nIntervalle);
                }
                else {
                        _nIntervalle = setInterval(this, "increment", 1000, nKMH);
                }
        }
        private function increment(nKMH:Number):Void {
                _nKilometres += nKMH;
        }
}


Si vous ne l’avez pas déja fait, créez un répertoire com/person13 à l’intérieur du répertoire spécifié dans votre classpath. Par exemple, si votre classpath indique D:\ActionScriptClasses, alors assurez vous bien d’avoir créé : D:\ActionScriptClasses\com\person13.

Sauver le fichier classe AS sous le nom Voiture.as dans le répertoire com/person13.
Ouvrez un nouveau document Flash (.fla).

Sur la première image de la timeline ajoutez le code suivant :

 
ActionScript:

import com.person13.Voiture;

// Commençons par une fonction qui affichera la valeur de la propriété kilometre
// pour un objet Voiture
function displayKilometrage(voitureObj:Voiture):Void {
        trace(voitureObj.kilometres);
}

// Créons l'objet voiture
var voiture:Voiture = new Voiture("Oldsmobile", "Alero", 2000, 43000);

// Disons maintenant à la voiture de rouler à 65 kilomètres heure
voiture.conduire(65);

// Créons un interval pour que le kilomètrage de l'objet Voiture
// s'affiche en permanence.
setInterval(displayKilometrage, 100, voiture);


Testez le clip.
Vous devriez voir le kilométrage de la voiture dans la fenêtre de sortie. Il devrait augmenter de 65 à chaque seconde.


Conclusion

Dans cet article j’ai abordé les principes de base concernant les classes en ActionScript 2.0. Je ne suis pas entré dans les détails au niveau de l’héritage ou de l’implémentation d’interfaces. J’ai préféré garder ces concepts pour une 3ème partie, cet article est déjà assez long.

Merci de m’avoir lu.