As3 Learning

Formation
ACTIONSCRIPT 3.0
Informations juridiques
Informations juridiques
Vous trouverez des informations juridiques ladresse http://help.adobe.com/fr_FR/legalnotices/index.html.
Dernire mise jour le 16/5/2011
iii
Sommaire
Chapitre 1 : Introduction ActionScript 3.0 A propos dActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Avantages dActionScript 3.0 Nouveauts dActionScript 3.0 .......................................................................................... 1 ......................................................................................... 2
Chapitre 2 : Prise en main dActionScript Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Utilisation des objets .................................................................................................. 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Elments de programme courants
Exemple : Elment de portfolio danimation (Flash Professional) Cration dapplications avec ActionScript Cration de vos propres classes
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Exemple : Cration dune application de base
Chapitre 3 : Syntaxe et langage ActionScript Prsentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Objets et classes Variables Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 Packages et espaces de noms Types de donnes Oprateurs Boucles Fonctions
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Instructions conditionnelles
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Chapitre 4 : Programmation oriente objets en ActionScript Introduction la programmation oriente objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 Classes Interfaces Hritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Rubriques avances
Exemple : GeometricShapes
Chapitre 1 : Introduction ActionScript 3.0

A propos dActionScript
ActionScript est le langage de programmation des environnements dexcution dAdobe Flash Player et Adobe AIR. Il assure linteractivit, le traitement des donnes et bien dautres fonctions pour le contenu Flash, Flex et AIR et les applications associes. ActionScript sexcute dans la machine virtuelle ActionScript (AVM), un composant de Flash Player et AIR. Le code ActionScript est gnralement compil en pseudo-code (sorte de langage de programmation crit et compris par les ordinateurs) par un compilateur, tel celui intgr Adobe Flash Professional ou celui intgr Adobe Flash Builder et fourni dans le kit de dveloppement SDK dAdobe Flex. Le pseudo-code est intgr aux fichiers SWF, qui sont excuts par Flash Player et AIR. ActionScript 3.0 constitue un modle de programmation solide, bien connu des dveloppeurs possdant des connaissances lmentaires sur la programmation oriente objets. Parmi les principales fonctionnalits dActionScript 3.0 qui ont t amliores par rapport aux versions antrieures dActionScript figurent :
Une nouvelle machine virtuelle ActionScript, appele AVM2, qui exploite un nouveau jeu dinstructions de
pseudo-code binaire et amliore grandement les performances.
Un code de compilateur plus moderne qui effectue des optimisations de plus bas niveau que les versions antrieures
du compilateur.
Une interface de programmation (API) tendue et amliore, avec contrle de bas niveau des objets et un vritable
modle orient objet.
Une API XML reposant sur la spcification ECMAScript pour XML (E4X) (ECMA-357 niveau 2). E4X est une
extension de langage dECMAScript qui ajoute XML comme type de donnes natif.
Un modle dvnements fond sur la spcification dvnements du modle dobjet de document (DOM,
Document Object Model) niveau 3.
Avantages dActionScript 3.0

Les possibilits dActionScript 3.0 dpassent largement les fonctions de programmation des versions prcdentes. Cette version est conue pour faciliter la cration dapplications trs complexes impliquant dimportants jeux de donnes et des bases de code orientes objet et rutilisables. Si ActionScript 3.0 nest pas indispensable lexcution de contenu dans Adobe Flash Player, il ouvre nanmoins la voie des amliorations de performance uniquement disponibles dans AVM2 (la machine virtuelle dActionScript 3.0). Le code dActionScript 3.0 peut sexcuter jusqu dix fois plus vite que le code des versions antrieures dActionScript. Lancienne version de la machine virtuelle, AVM1, excute le code ActionScript 1.0 et ActionScript 2.0. Elle est prise en charge par Flash Player 9 et 10 pour assurer la compatibilit ascendante avec le contenu existant.
FORMATION ACTIONSCRIPT 3.0

Introduction ActionScript 3.0
Nouveauts dActionScript 3.0

Bien que de nombreuses classes et fonctions dActionScript 3.0 sapparentent celles dActionScript 1.0 et 2.0, son architecture et sa conceptualisation diffrent des versions prcdentes. Parmi les amliorations dActionScript 3.0, on compte de nouvelles fonctions du langage de base et une API avance, qui accrot le contrle des objets de bas niveau.
Fonctions du langage de base

Le langage de base dfinit les lments de construction fondamentaux du langage de programmation, par exemple les arguments, expressions, conditions, boucles et types. ActionScript 3.0 contient de nombreuses fonctions qui acclrent le processus de dveloppement. Exceptions dexcution ActionScript 3.0 peut signaler davantage de conditions derreur que les versions prcdentes. Utilises pour les conditions derreur courantes, les exceptions dexcution amliorent la procdure de dbogage et vous permettent de dvelopper des applications susceptibles de grer les erreurs de manire fiable. Les erreurs dexcution peuvent fournir des traces de pile qui identifient le fichier source et le numro de ligne, pour un reprage plus rapide des erreurs. Types dexcution Dans ActionScript 3.0, les informations de type sont prserves lors de lexcution. Elles permettent de vrifier les types lors de lexcution, optimisant ainsi lintgrit des types du systme. Les informations de type servent galement reprsenter les variables dans les reprsentations machine natives, ce qui accrot les performances et rduit lutilisation de la mmoire. Dans ActionScript 2.0, les annotations de type visent avant tout aider le dveloppeur ; lors de lexcution, toutes les valeurs sont types dynamiquement. Classes scelles ActionScript 3.0 introduit le concept de classe scelle. Une telle classe possde uniquement un jeu fixe de proprits et de mthodes, dfinies lors de la compilation. Il est impossible den ajouter dautres. Ainsi, la vrification effectue au moment de la compilation est plus stricte et garantit une plus grande robustesse des programmes. Lutilisation de la mmoire est galement optimise puisquune table de hachage interne nest pas requise pour chaque occurrence dobjet. Les classes dynamiques sont galement disponibles par le biais du mot-cl dynamic. Bien que scelles par dfaut, toutes les classes dActionScript 3.0 peuvent tre dclares dynamiques grce au mot-cl dynamic. Fermetures de mthodes ActionScript 3.0 permet lutilisation dune fermeture de mthode qui se rappelle automatiquement loccurrence de son objet dorigine. Cette fonction savre utile dans le traitement des vnements. Dans ActionScript 2.0, les fermetures de mthode ne gardent pas la trace de loccurrence dobjet partir de laquelle elles ont t extraites, do un comportement inattendu lors de lappel de la fermeture de mthode. ECMAScript pour XML (E4X) ActionScript 3.0 intgre ECMAScript pour XML (E4X), rcemment normalis sous le nom ECMA-357. E4X offre un jeu dlments de langage naturels et courants qui permettent de manipuler XML. Contrairement aux API classiques danalyse XML, XML et E4X fonctionnent comme un type de donnes natif du langage. E4X simplifie le dveloppement dapplications exploitant XML grce une rduction drastique du volume de code requis. Pour visualiser la spcification E4X dECMA, aller www.ecma-international.org (disponible en anglais uniquement).

Expressions rgulires ActionScript 3.0 inclut une prise en charge native des expressions rgulires afin dacclrer la recherche et la manipulation des chanes. Dans ActionScript 3.0, cette prise en charge suit la version 3 de la spcification de langage ECMAScript (ECMA-262). Espaces de noms Les espaces de noms sont semblables aux spcificateurs daccs classiques qui assurent le contrle de visibilit des dclarations (public, private, protected). Ils fonctionnent comme des spcificateurs daccs personnaliss, qui portent le nom de votre choix. Les espaces de noms sont dots dun identifiant de ressource universel (URI, Universal Resource Identifier) afin dviter les collisions. Ils servent galement reprsenter les espaces de noms XML en cas dutilisation dE4X. Nouveaux types de primitives ActionScript 3.0 comprend trois types numriques : Number, int et uint. Number reprsente un nombre en virgule flottante deux dcimales. Le type int est un entier sign 32 bits qui permet au code ActionScript de profiter de la rapidit de traitement mathmatique de lunit centrale. Il savre pratique pour les compteurs de boucles et les variables utilisant des entiers. Le type uint est un type dentier non sign 32 bits, utile pour les valeurs de couleurs RVB, les compteurs doctets, etc. ActionScript 2.0, en revanche, utilise un seul type numrique, Number.
Fonctions API
Les API dActionScript 3.0 contiennent un grand nombre de classes qui vous permettent de contrler les objets de bas niveau. Larchitecture du langage est conue pour tre plus intuitive que les versions antrieures. Ces nouvelles classes tant trop nombreuses pour autoriser une prsentation dtaille ce stade, il est utile de mettre en avant quelques changements significatifs. Modle dvnements DOM3 Le modle dvnements Document Object Model de niveau 3 (DOM3) offre une mthode standard de gnration et de traitement des messages dvnement. Il permet aux objets composant les applications dinteragir et de communiquer tout en conservant leur tat et en ragissant aux changements. Etabli partir des spcifications dvnements DOM niveau 3 du World Wide Web Consortium, ce modle fournit un mcanisme plus clair et plus efficace que les systmes dvnements disponibles dans les versions antrieures dActionScript. Les vnements et vnements derreur se trouvent dans le package flash.events. Les composants Flash Professional et la structure Flex utilisant le mme modle dvnements, le systme dvnements est unifi sur lensemble de la plateforme Flash. API de liste daffichage LAPI daccs la liste daffichage, cest--dire larborescence contenant tous les lments visuels de lapplication, est constitue de classes permettant de manipuler les primitives visuelles. La classe Sprite est un lment de construction lger, adapte la classe de base des lments visuels tels que les composants dinterface. La classe Shape reprsente des formes vectorielles brutes. Il est possible dinstancier ces classes naturellement laide de loprateur new, mais aussi de les redfinir dynamiquement comme parent tout moment. La gestion de profondeur est automatique. Des mthodes permettent de spcifier et de grer lordre de superposition des objets.

Gestion des donnes et contenus dynamiques ActionScript 3.0 comprend des mcanismes de chargement et de gestion des actifs et des donnes au sein de lapplication qui se caractrisent par leur intuitivit et leur cohrence dans lensemble de lAPI. La classe Loader propose un unique mcanisme de chargement des fichiers SWF et des actifs dimage, et permet daccder des informations dtailles sur le contenu charg. La classe URLLoader offre un mcanisme distinct de chargement du texte et des donnes binaires dans les applications orientes donnes. La classe Socket permet la lecture et lcriture des donnes binaires dans les sockets de serveur, quel que soit le format. Accs aux donnes de bas niveau Diverses API permettent daccder des donnes de bas niveau. Pour le tlchargement de donnes, la classe URLStream donne accs aux donnes sous forme binaire brute pendant le tlchargement. Avec la classe ByteArray, vous pouvez optimiser la lecture, lcriture et la manipulation des donnes binaires. LAPI Sound assure le contrle prcis du son par le biais des classes SoundChannel et SoundMixer. Des API lies la scurit fournissent des informations sur les droits de scurit dun fichier SWF ou du contenu charg, pour une gestion plus efficace des erreurs de scurit. Utilisation de texte ActionScript 3.0 contient un package flash.text destin lensemble des API relatives au texte. La classe TextLineMetrics propose des mesures dtailles relatives une ligne de texte au sein dun champ de texte. Elle remplace la mthode TextFormat.getTextExtent() dActionScript 2.0. La classe TextField contient diverses mthodes de bas niveau, qui fournissent des informations dtermines sur une ligne de texte ou un caractre unique dans un champ de texte. Par exemple, la mthode getCharBoundaries() renvoie un rectangle reprsentant le cadre de slection dun caractre. La mthode getCharIndexAtPoint() renvoie lindex dun caractre un point donn. La mthode getFirstCharInParagraph() renvoie lindex du premier caractre dun paragraphe. Les mthodes de niveau de ligne incluent getLineLength(), qui renvoie le nombre de caractres dune ligne de texte donne, et getLineText(), qui renvoie le texte de la ligne spcifie. La classe Font permet de grer les polices intgres des fichiers SWF. Les classes du package flash.text.engine, qui constituent Flash Text Engine, sont conues pour un contrle de bas niveau du texte et permettent de crer des structures et des composants texte.
Chapitre 2 : Prise en main dActionScript

Concepts de programmation de base
ActionScript tant un langage de programmation, il vous sera plus facile de lapprendre si vous matrisez dj quelques concepts gnraux de programmation.
Quel est le rle dun programme informatique ?

Pour commencer, il est intressant davoir une ide conceptuelle de la nature et du rle dun programme informatique. Celui-ci prsente deux aspects principaux :
Il est constitu dune srie dinstructions ou dtapes que lordinateur doit effectuer. Chaque tape implique terme la manipulation dinformations ou de donnes.
En fait, un programme informatique nest rien dautre quune liste dactions que vous demandez lordinateur dexcuter lune aprs lautre. Chacune de ces demandes dexcution daction sappelle une instruction. Dans ActionScript, chaque instruction se termine par un point-virgule. Par nature, le seul rle dune instruction de programme consiste manipuler quelques donnes stockes dans la mmoire de lordinateur. Prenons un exemple simple : vous indiquez lordinateur de faire la somme de deux nombres et de stocker le rsultat en mmoire. Dans un cas de figure plus compliqu, imaginez un rectangle dessin sur lcran ; vous rdigez un programme pour le dplacer un autre emplacement de lcran. Lordinateur mmorise certaines informations relatives au rectangle : les coordonnes x, y de sa position, sa largeur et sa hauteur, sa couleur, etc. Chacune de ces informations est stocke dans la mmoire de lordinateur. Un programme de dplacement du rectangle comporterait des tapes telles que rgler la coordonne x sur 200 ; rgler la coordonne y sur 150. En dautres termes, il dfinirait de nouvelles valeurs pour les coordonnes x et y. En arrire-plan, lordinateur manipule ces donnes pour convertir les nombres en images visibles lcran. Il suffit cependant de savoir que le processus de dplacement dun rectangle lcran implique uniquement la modification de donnes dans la mmoire de lordinateur.
Variables et constantes
La programmation consiste principalement modifier des informations dans la mmoire de lordinateur. Il est donc important de disposer dun moyen permettant de reprsenter une information unique dans un programme. Une variable est un nom qui reprsente une valeur dans la mmoire de lordinateur. Lorsque vous rdigez des instructions visant manipuler des valeurs, vous crivez le nom de la variable plutt que la valeur. Chaque fois que lordinateur rencontre le nom de la variable dans le programme, il cherche dans sa mmoire la valeur utiliser. Si vous disposez par exemple de deux variables appeles value1 et value2, chacune contenant un nombre, vous pouvez additionner ces deux nombres laide de linstruction suivante :
value1 + value2
Lorsquil excute vritablement la procdure, lordinateur recherche les valeurs correspondant chaque variable et les ajoute. Dans ActionScript 3.0, une variable se compose de trois lments :
Le nom de la variable Le type de donnes qui peut tre stock dans la variable

Prise en main dActionScript
La valeur relle stocke dans la mmoire de lordinateur

Nous venons de voir comment lordinateur utilise le nom comme un espace rserv destin la valeur. Le type de donnes a galement une importance. Lorsque vous crez une variable dans ActionScript, vous indiquez le type spcifique de donnes auquel elle est rserve. Les instructions du programme peuvent alors uniquement stocker ce type de donnes dans la variable. Vous pouvez manipuler la valeur laide des caractristiques particulires associes ce type de donnes. Dans ActionScript, la cration dune variable (on parle galement de dclaration de variable) seffectue laide de linstruction var :
var value1:Number;
Dans cet exemple, nous indiquons lordinateur de crer la variable value1, qui peut uniquement contenir des donnes Number, un type de donnes spcialement dfini dans ActionScript. Il est galement possible de stocker immdiatement une valeur dans la variable :
var value2:Number = 17;
Adobe Flash Professional Flash Professional propose une autre mthode de dclaration des variables. Lorsque vous placez un symbole de clip, un symbole de bouton ou un champ de texte sur la scne, vous pouvez lui attribuer un nom doccurrence dans lInspecteur des proprits. En arrire-plan, Flash Professional cre une variable du mme nom que celui de loccurrence. Vous pouvez utiliser ce nom dans votre code ActionScript pour reprsenter cet lment de la scne. Par exemple, si un symbole de clip se trouve sur la scne et que vous lui attribuez le nom rocketShip, chaque fois que vous utilisez la variable rocketShip dans le code ActionScript, cest en fait ce clip que vous manipulez.
Une constante sapparente une variable, dans la mesure o elle correspond un nom reprsentant une valeur dans la mmoire de lordinateur et est associe un type de donnes spcifique. En revanche, vous ne pouvez affecter quune seule valeur une constante dans une application ActionScript. Une fois affecte une constante, une valeur reste la mme dans lensemble de lapplication. La syntaxe de dclaration dune constante est identique celle de la dclaration dune variable, la diffrence prs que vous substituez le mot-cl const au mot-cl var :
const SALES_TAX_RATE:Number = 0.07;
Une constante permet de dfinir une valeur qui sutilise plusieurs emplacements dans un projet et reste identique dans des circonstances normales. Lutilisation dune constante plutt que dune valeur littrale amliore la lisibilit de votre code. Considrons par exemple deux versions dun mme code. Lune multiplie un prix par SALES_TAX_RATE, tandis que lautre le multiplie par 0.07. La version contenant la constante SALES_TAX_RATE est plus facile comprendre. Imaginons, en outre, que la valeur dfinie par la constante change. Si vous reprsentez cette valeur par une constante dans lensemble du projet, il vous suffit dintervenir un seul emplacement (dans la dclaration de la constante), alors que si vous utilisez des valeurs littrales codes en dur, vous devez changer chaque occurrence.
Types de donnes
Dans ActionScript, de nombreux types de donnes sont votre disposition pour la cration de variables. Certains dentre eux peuvent tre considrs comme simples ou fondamentaux :
String : une valeur textuelle, telle quun nom ou le texte dun chapitre de livre Numeric : ActionScript 3.0 inclut trois types de donnes spcifiques aux valeurs numriques : Number : toute valeur numrique, y compris les valeurs avec ou sans fraction int : un nombre entier (sans fraction) uint : un nombre entier non sign , cest--dire, un nombre entier qui ne peut pas tre ngatif

Boolean : une valeur vrai/faux, qui indique par exemple si une instruction Switch est active ou si deux valeurs sont
gales Les types de donnes simples reprsentent une information unique : un nombre ou une squence de texte, par exemple. Cependant, la majorit des types de donnes dfinis dans ActionScript sont complexes car ils reprsentent un ensemble de valeurs regroupes dans un mme conteneur. Par exemple, une variable du type Date reprsente une valeur unique (un point temporel). Toutefois, la valeur date se compose en ralit de plusieurs valeurs (le jour, le mois, lanne, les heures, les minutes, les secondes, etc.), qui correspondent elles-mmes des nombres individuels. Ainsi, bien que nous percevions une date comme une valeur unique (et quil soit possible de la traiter comme telle en crant une variable Date), lordinateur, en interne, la considre comme un groupe de valeurs qui, ensemble, dfinissent une seule date. La plupart des types de donnes intgrs et ceux dfinis par les programmeurs sont des types de donnes complexes. Voici quelques exemples de types de donnes complexes que vous connaissez probablement :
MovieClip : un symbole de clip TextField : un champ de texte dynamique ou saisi SimpleButton : un symbole de bouton Date : une information relative un point temporel (date et heure)
Deux termes sont souvent utiliss comme synonymes de type de donnes : classe et objet. Une classe est tout simplement la dfinition dun type de donnes ; un modle, en quelque sorte, sappliquant tous les objets du type de donnes et qui revient dire toutes les variables du type de donnes Exemple sont dotes des caractristiques suivantes : A, B et C . Un objet, quant lui, est une occurrence relle dune classe. Une variable dont le type de donnes correspond MovieClip, par exemple, peut tre dcrite comme un objet MovieClip. Les exemples ci-aprs dcrivent la mme chose :
Le type de donnes de la variable myVariable est Number. La variable myVariable est une occurrence de Number. La variable myVariable est un objet Number. La variable myVariable est une occurrence de la classe Number.
Utilisation des objets

ActionScript constitue ce que lon appelle un langage de programmation orient objet. Un langage de programmation orient objet est une simple approche de la programmation, rien dautre quune manire dorganiser le code dun programme laide dobjets. Nous avons dfini plus haut un programme informatique comme une srie de procdures ou dinstructions que lordinateur effectue. Nous pouvons alors considrer quun programme informatique nest quune longue liste dinstructions. Dans le cas de la programmation oriente objets, cependant, les instructions du programme se divisent en diffrents objets : le code tant rassembl en groupes de fonctionnalits, un mme conteneur runit des types de fonctionnalits et des informations connexes. Adobe Flash Professional Si vous avez travaill avec des symboles dans Flash Professional, vous savez dj manipuler les objets. Imaginons que vous ayez dfini un symbole de clip (le dessin dun rectangle, par exemple) et vous en ayez plac une copie sur la scne. Ce symbole de clip constitue aussi un objet (au sens littral) dans ActionScript ; il sagit dune occurrence de la classe MovieClip.

Vous avez la possibilit de modifier plusieurs caractristiques du clip. Lorsquil est slectionn, vous pouvez modifier certaines valeurs de lInspecteur des proprits, telles que la coordonne x ou la largeur. Vous pouvez galement effectuer diffrents rglages de couleur comme la transparence alpha, ou encore lui appliquer un filtre dombre porte. Dautres outils Flash Professional permettent deffectuer davantage de modifications, par exemple loutil Transformation libre pour faire pivoter le rectangle. Toutes ces actions de transformation du symbole de clip disponibles dans Flash Professional le sont galement dans ActionScript. Pour les utiliser, vous devez modifier les donnes runies dans un ensemble appel objet MovieClip.
Dans la programmation oriente objets que propose ActionScript, chaque classe comprend trois types de caractristiques :
Proprits Mthodes Evnements

Ces lments servent grer les donnes que le programme utilise, et dterminer les actions excuter ainsi que lordre dexcution.
Proprits
Une proprit reprsente lune des donnes runies dans un objet. Un objet song, par exemple, peut prsenter des proprits appeles artist et title. La classe MovieClip possde des proprits telles que rotation, x, width et alpha. Les proprits sutilisent comme des variables individuelles. On pourrait mme les envisager comme les variables enfant dun objet. Voici des exemples de code ActionScript utilisant des proprits. Cette ligne de code dplace lobjet MovieClip nomm
square vers la coordonne x de 100 pixels : square.x = 100;
Le code ci-aprs utilise la proprit rotation pour faire pivoter le MovieClip square de manire lui donner la mme orientation que le MovieClip triangle :
square.rotation = triangle.rotation;
Ce code modifie lchelle horizontale du MovieClip square pour quil soit une fois et demie plus large que prcdemment :
square.scaleX = 1.5;
Observez la structure commune : vous utilisez une variable (square, triangle) comme nom de lobjet, suivi dun point() puis du nom de la proprit (x, rotation, scaleX). Le point, ou oprateur point, sert indiquer que vous accdez lun des lments enfant dun objet. La structure dans son ensemble, nom de variable-point-nom de proprit est utilise telle une variable, comme le nom dune valeur unique dans la mmoire de lordinateur.
Mthodes
Une mthode est une action qui peut tre effectue par un objet. Par exemple, si vous avez labor, dans Flash Professional, un symbole de clip dont le scnario contient plusieurs images cls et animations, ce clip peut tre lu ou arrt, ou recevoir linstruction de placer la tte de lecture sur une image donne. Le code ci-dessous indique au MovieClip nomm shortFilm de commencer la lecture :
shortFilm.play();

Cette ligne de code arrte la lecture du MovieClip shortFilm (la tte de lecture sarrte lendroit o elle se trouve, comme lorsque vous mettez une vido en pause) :
shortFilm.stop();
Ce code-ci indique au MovieClip shortFilm de placer la tte de lecture sur Frame 1 et darrter la lecture (comme si vous rembobiniez une vido) :
shortFilm.gotoAndStop(1);
Laccs aux mthodes, comme pour les proprits, seffectue en crivant le nom de lobjet (une variable) suivi dun point puis du nom de la mthode et de parenthses. Les parenthses servent indiquer que vous appelez la mthode, cest--dire, que vous demandez lobjet deffectuer une action. Il arrive que des valeurs (ou variables) soient places dans ces parenthses de manire transmettre des informations supplmentaires ncessaires lexcution de laction. On appelle ces valeurs des paramtres de mthode. Par exemple, la mthode gotoAndStop() doit savoir quelle image atteindre ; un paramtre est donc requis dans les parenthses. Dautres mthodes, telles play() et stop(), ont une signification univoque et nont donc besoin daucune information complmentaire. Elles sont nanmoins suivies de parenthses. Contrairement aux proprits (et aux variables), les mthodes ne servent pas despaces rservs. Certaines mthodes peuvent cependant effectuer des calculs et renvoyer des rsultats pouvant servir de variables. Cest le cas de la mthode toString() de la classe Number, qui convertit une valeur numrique en une reprsentation textuelle :
var numericData:Number = 9; var textData:String = numericData.toString();
Par exemple, vous pouvez utiliser la mthode toString() si vous souhaitez afficher la valeur dune variable Number dans un champ de texte lcran. La proprit text de la classe TextField (qui reprsente le contenu textuel rel affich lcran) se dfinit comme une chane (String), de sorte quelle ne puisse contenir que des valeurs textuelles. Cette ligne de code convertit la valeur numrique de la variable numericData en texte, puis la fait apparatre lcran dans lobjet TextField nomm calculatorDisplay :
calculatorDisplay.text = numericData.toString();
Evnements
Un programme informatique est une srie dinstructions que lordinateur excute lune aprs lautre. Certains programmes trs simples ne sont rien de plus : lordinateur excute quelques procdures, puis le programme se termine. Toutefois, les programmes ActionScript sont conus pour poursuivre leur excution, dans lattente dune saisie utilisateur, par exemple. Les vnements sont des mcanismes qui dterminent quelles instructions lordinateur doit excuter et quel moment. Par essence, les vnements sont des faits qui surviennent et auxquels ActionScript peut rpondre parce quil en est conscient au moment o ils se produisent. De nombreux vnements sont lis linteraction de lutilisateur, par exemple un clic sur un bouton ou une pression sur une touche du clavier. Il existe nanmoins dautres types dvnements. Par exemple, si vous utilisez ActionScript pour charger une image externe, il existe un vnement capable de vous prvenir lorsque le chargement de limage est termin. Pendant son excution, un programme ActionScript attend que des vnements se produisent et, lorsque cest le cas, il excute le code ActionScript que vous avez spcifi en rponse.

10
Gestion des vnements de base

La gestion des vnements est la technique qui permet de spcifier les actions excuter en rponse des vnements particuliers. Lors de lcriture de code ActionScript en vue de la gestion des vnements, trois lments importants sont identifier :
Source de lvnement : quel objet sera concern par lvnement ? Par exemple, sur quel bouton a eu lieu le clic ou
quel est lobjet Loader qui charge limage ? La source de lvnement est galement appele cible de lvnement car elle reprsente lobjet o lvnement est cibl (l o lvnement a lieu).
Evnement : que doit-il se passer, quel vnement voulez-vous rpondre? Il est important didentifier
correctement lvnement, car de nombreux objets dclenchent plusieurs vnements.
Rponse : quelles actions doivent tre excutes lorsque lvnement se produit ?

Tout code ActionScript de gestion des vnements doit contenir ces trois lments et respecter la structure de base suivante (les lments en gras sont des espaces rservs remplir selon le cas envisag) :
function eventResponse(eventObject:EventType):void { // Actions performed in response to the event go here. } eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);
Ce code a un double rle. Tout dabord, il dfinit une fonction, qui est une manire de spcifier les actions excuter en rponse lvnement. Ensuite, il appelle la mthode addEventListener() de lobjet source, inscrivant ainsi la fonction auprs de lvnement spcifi de manire que, ds que lvnement survient, les actions de la fonction aient lieu. Nous allons tudier chacun de ces rles en dtail. Une fonction sert regrouper des actions sous un nom unique, un raccourci qui vous permet de les excuter. La fonction est identique la mthode, cette exception prs quelle nest pas ncessairement associe une classe particulire (on pourrait dailleurs dfinir la mthode ainsi : une fonction associe une classe donne). Lorsque vous crez une fonction de gestion des vnements, vous devez choisir le nom de la fonction (dans ce cas eventResponse) mais aussi spcifier un paramtre (eventObject) dans cet exemple). La spcification dun paramtre de fonction ressemble la dclaration de variable ; vous devez dans ce cas aussi indiquer le type de donnes du paramtre (EventType, dans cet exemple). Chaque type dvnement que vous souhaitez couter est associ une classe ActionScript. Le type de donnes que vous spcifiez pour le paramtre de fonction correspond systmatiquement la classe associe lvnement auquel vous souhaitez ragir. Par exemple, un vnement click (dclench par un clic de souris sur un lment) est associ la classe MouseEvent. Pour crire une fonction dcouteur pour un vnement click, vous lui associez un paramtre de type MouseEvent. Enfin, entre les accolades douverture et de fermeture ({ ... }), vous placez les instructions que lordinateur doit excuter lorsque lvnement a lieu. La fonction de gestion de lvnement est crite. Vous indiquez ensuite lobjet source (celui qui provoque lvnement, par exemple le bouton) que cette fonction doit tre appele lorsque lvnement survient. Pour ce faire, vous appelez la mthode addEventListener() de cet objet (tous les objets lis des vnements ont galement une mthodeaddEventListener()). La mthode addEventListener() rclame deux paramtres :
Tout dabord, le nom de lvnement auquel vous voulez rpondre. Chaque vnement est affili une classe
spcifique pour laquelle est dfinie une valeur propre chacun deux (en quelque sorte le nom unique de lvnement). Cette valeur sert de premier paramtre.
Vient ensuite le nom de votre fonction de rponse lvnement. Sachez quun nom de fonction est crit sans
parenthses lors du transfert en tant que paramtre.

11
Processus de gestion dvnement

Vous trouverez ci-dessous une description dtaille du processus ayant lieu lorsque vous crez un couteur dvnements. Dans ce cas, il sagit dun exemple illustrant la cration dune fonction dcouteur appele lorsque vous cliquez sur un objet myButton. Le code crit par le programmeur est le suivant :
function eventResponse(event:MouseEvent):void { // Actions performed in response to the event go here. } myButton.addEventListener(MouseEvent.CLICK, eventResponse);
Voici comment ce code devrait fonctionner lorsquil est excut :

1 Lors du chargement du fichier SWF, lordinateur remarque quil existe une fonction eventResponse().
2 Il excute ensuite le code (notamment les lignes de code qui ne sont pas dans une fonction). Dans ce cas, il sagit
dune seule ligne de code : lappel de la mthode addEventListener() sur lobjet source de lvnement (myButton) et la transmission de la fonction eventResponse en tant que paramtre.

12
En interne, myButton a une liste des fonctions qui coutent chaque vnement. Lorsque sa mthode addEventListener() est appele, myButton stocke la fonction eventResponse() dans sa liste dcouteurs dvnements.
3 A un certain moment, lutilisateur clique sur lobjet myButton et dclenche ainsi son vnement click (identifi
comme MouseEvent.CLICK dans le code).
A ce stade, les oprations suivantes ont lieu :

a Un objet est cr, une occurrence de la classe associe lvnement en question (MouseEvent dans cet
exemple). Pour de nombreux vnements, il sagit dune occurrence de la classe Event ; pour des vnements de souris, une occurrence de MouseEvent et pour dautres vnements, une occurrence de la classe qui leur est associe. Lobjet cr est appel lobjet vnement. Il contient des informations spcifiques sur lvnement qui sest produit : son type, lemplacement o il a eu lieu et toute autre information pertinente.

13
b Lordinateur consulte ensuite la liste des couteurs dvnements stocks par myButton. Il parcourt ces
fonctions lune aprs lautre en les appelant et en transmettant lobjet vnement la fonction en tant que paramtre. Etant donn que la fonction eventResponse() est lun des couteurs de myButton, lordinateur appelle la fonction eventResponse() dans le cadre de ce processus.
c Lorsque la fonction eventResponse() est appele, le code quelle contient est excut et vos actions spcifies
sont effectues.
Exemples de gestion dvnements

Voici quelques exemples plus concrets dvnements qui vous donneront une ide des lments les plus courants et des variations que vous pourrez utiliser lors de lcriture de votre propre code de gestion des vnements :
Clic sur un bouton pour lancer la lecture du clip actif. Dans lexemple suivant, playButton est le nom doccurrence
du bouton et this est un nom spcial qui signifie lobjet actif :
this.stop(); function playMovie(event:MouseEvent):void { this.play(); } playButton.addEventListener(MouseEvent.CLICK, playMovie);
Dtection de la saisie dans un champ de texte. Dans cet exemple, entryText est un champ de saisie de texte et
outputText est un champ de texte dynamique :

14
function updateOutput(event:TextEvent):void { var pressedKey:String = event.text; outputText.text = "You typed: " + pressedKey; } entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);
Clic sur un bouton pour atteindre une URL. Dans ce cas, linkButton est le nom doccurrence du bouton :
function gotoAdobeSite(event:MouseEvent):void { var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/"); navigateToURL(adobeURL); } linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);
Cration doccurrences dobjets

Pour utiliser un objet dans ActionScript, cet objet doit exister. La cration dun objet repose en partie sur la dclaration dune variable. Toutefois, celle-ci cre uniquement un emplacement vide dans la mmoire de lordinateur. Avant dutiliser ou de manipuler une variable, attribuez-lui toujours une valeur relle (en crant un objet et en le stockant dans la variable). Le processus de cration dun objet est appel instanciation de lobjet, soit la cration dune occurrence dune classe particulire. La cration dune occurrence dobjet peut passer par une mthode simple qui nimplique pas ActionScript. Dans Flash Professional, placez un symbole de clip, un symbole de bouton ou un champ de texte sur la scne, puis attribuez-lui un nom doccurrence. Lapplication dclare automatiquement une variable dote de ce nom doccurrence, cre une occurrence dobjet et stocke cet objet dans la variable. Il en va de mme dans Flex : vous crez un composant MXML, soit par codage dune balise MXML, soit en plaant le composant dans lditeur de Flash Builder en mode Cration. Lorsque vous lui attribuez un identifiant, celui-ci devient le nom dune variable ActionScript contenant une occurrence de ce composant. Toutefois, il nest pas toujours possible de crer un objet visuellement (notamment dans le cas des objets non visuels). Plusieurs mthodes permettent aussi de crer des occurrences dobjet laide dActionScript uniquement. A partir de plusieurs types de donnes ActionScript, vous pouvez crer une occurrence en utilisant une expression littrale, une valeur crite directement dans le code ActionScript. Voici quelques exemples :
Valeur numrique littrale (entrez le nombre directement) :

var someNumber:Number = 17.239; var someNegativeInteger:int = -53; var someUint:uint = 22;
Valeur de chane littrale (entourez le texte de doubles guillemets) :

var firstName:String = "George"; var soliloquy:String = "To be or not to be, that is the question...";
Valeur boolenne littrale (utilisez la valeur littrale true ou false) :

var niceWeather:Boolean = true; var playingOutside:Boolean = false;
Valeur de tableau littrale (placez entre crochets une liste de valeurs spares par des virgules) :
var seasons:Array = ["spring", "summer", "autumn", "winter"];

15
Valeur XML littrale (entrez le XML directement) :

var employee:XML = <employee> <firstName>Harold</firstName> <lastName>Webster</lastName> </employee>;
ActionScript dfinit galement des expressions littrales pour les types de donnes Array, RegExp, Object et Function. Pour tout type de donnes, le plus simple consiste crer une occurrence dobjet laide de loprateur new et du nom de classe, comme suit :
var raceCar:MovieClip = new MovieClip(); var birthday:Date = new Date(2006, 7, 9);
Pour cette mthode de cration dun objet laide de loprateur new, on parle souvent dappeler le constructeur de la classe . Un constructeur est une mthode spciale qui est appele dans le cadre de la cration dune occurrence de classe. Notez que lorsque vous crez une occurrence ainsi, vous placez des parenthses aprs le nom de classe et spcifiez parfois des valeurs de paramtres dans les parenthses, comme vous le faites lorsque vous appelez une mthode. Vous pouvez utiliser loprateur new pour crer une occurrence dobjet, mme pour les types de donnes qui permettent de crer des occurrences avec une expression littrale. Par exemple, ces deux lignes de code produisent le mme rsultat :
var someNumber:Number = 6.33; var someNumber:Number = new Number(6.33);
Il est important de se familiariser avec la mthode new NomClasse() de cration dobjets. De nombreux types de donnes ActionScript ne disposent pas de reprsentation visuelle. Il est donc impossible de les crer en plaant un lment sur la scne de Flash Professional ou en mode Cration dans lditeur MXML de Flash Builder. Dans ce cas, vous pouvez uniquement crer une occurrence dans ActionScript laide de loprateur new. Adobe Flash Professional Dans Flash Professional, loprateur new peut en outre servir crer une occurrence dun symbole de clip dfini dans la bibliothque sans tre plac sur la scne.
Voir aussi
Utilisation de tableaux Utilisation dexpressions rgulires Cration dobjets MovieClip laide dActionScript
Elments de programme courants

Dautres lments de construction peuvent servir la cration dun programme ActionScript.

16
Oprateurs
Les oprateurs sont des symboles spciaux (et parfois des mots) qui permettent deffectuer des calculs. Ils sont surtout utiliss dans les oprations mathmatiques et la comparaison de valeurs. En rgle gnrale, un oprateur utilise une ou plusieurs valeurs et tablit un rsultat unique. Exemple :
Loprateur de somme (+) ajoute deux valeurs pour obtenir un nombre unique :
var sum:Number = 23 + 32;
Loprateur de multiplication (*) multiplie une valeur par une autre pour obtenir un nombre unique :
var energy:Number = mass * speedOfLight * speedOfLight;
Loprateur dgalit (==) compare deux valeurs pour vrifier si elles sont gales, afin dobtenir une valeur vrai/faux
(boolenne) unique :
if (dayOfWeek == "Wednesday") { takeOutTrash(); }
Comme lindique la figure ci-dessus, loprateur dgalit et les autres oprateurs de comparaison sont le plus souvent utiliss avec linstruction ifafin de dterminer si certaines actions sont effectues ou non.
Commentaires
Lors de la rdaction du code ActionScript, il peut savrer utile de conserver des notes personnelles, expliquant par exemple le fonctionnement de certaines lignes de code ou la raison pour laquelle vous avez fait tel ou tel choix. Les commentaires de code permettent dinsrer dans du code du texte que lordinateur devra ignorer. ActionScript comprend deux types de commentaires :
Commentaire sur une ligne : un commentaire sur une ligne est signal par linsertion de deux barres obliques en un
emplacement quelconque dune ligne. Tout ce qui apparat aprs les barres obliques et jusqu la fin de la ligne est ignor par lordinateur :
// This is a comment; it's ignored by the computer. var age:Number = 10; // Set the age to 10 by default.
Commentaire sur plusieurs lignes : un commentaire sur plusieurs lignes comprend un marqueur de dbut (/*), le
commentaire lui-mme, puis un marqueur de fin de commentaire (*/). Lordinateur ignore tout ce qui apparat entre les marqueurs de dbut et de fin, quel que soit le nombre de lignes utilis par le commentaire :
/* This is a long description explaining what a particular function is used for or explaining a section of code. In any case, the computer ignores these lines. */
Une autre utilit des commentaires est de dsactiver temporairement une ou plusieurs lignes de code. Cest le cas, par exemple, si vous testez diffrentes faons daboutir un rsultat ou essayez didentifier pourquoi le code ActionScript ne fonctionne pas comme vous le pensiez.

17
Contrle du flux
Dans bien des cas, il vous sera ncessaire de rpter des actions de votre code, den effectuer certaines et pas dautres, de raliser des actions de remplacement selon les conditions rencontres, etc. Le contrle de flux permet de matriser les actions excutes. ActionScript propose plusieurs types dlments de contrle de flux.
Fonctions : les fonctions sont comme des raccourcis, elles permettent de regrouper sous un mme nom une srie
dactions qui serviront des calculs. Essentielles la gestion des vnements, elles constituent en outre un outil gnrique de regroupement des instructions.
Boucles : les structures en boucle permettent de dsigner un jeu dinstructions que lordinateur doit excuter un
nombre dfini de fois ou jusqu ce quune condition change. Souvent, les boucles sont utilises pour manipuler plusieurs lments connexes laide dune variable dont la valeur change chaque fois que lordinateur achve une boucle.
Instructions conditionnelles : les instructions conditionnelles permettent de dsigner certaines actions effectuer
uniquement dans certaines circonstances ou de dfinir des ensembles dactions destins diffrentes conditions. Linstruction conditionnelle la plus courante est if. Linstruction if vrifie la valeur ou lexpression place dans ses parenthses. Si le rsultat est true, les lignes de code entre accolades sont excutes ; dans le cas contraire, elles sont ignores. Exemple :
if (age < 20) { // show special teenager-targeted content }
Associe linstruction else, linstruction if permet de dsigner les actions effectuer si la condition nest pas vrifie (true) :
if (username == "admin") { // do some administrator-only things, like showing extra options } else { // do some non-administrator things }
Exemple : Elment de portfolio danimation (Flash Professional)

Cet exemple indique comment vous pouvez assembler des lments dActionScript dans une application complte. Llment de portfolio danimation est un exemple de la faon dont vous pourriez ajouter une animation linaire existante des lments interactifs mineurs. Vous pourriez, par exemple, incorporer une animation cre pour un client dans un portfolio en ligne. Les lments interactifs ajouter sont deux boutons sur lesquels lutilisateur peut cliquer : un pour lancer lanimation et un pour accder une URL distincte (telle que le menu du portfolio ou la page daccueil de lauteur). Le processus de cration de cet lment peut tre divis en quatre sections principales :
1 Prparer le fichier FLA pour ajouter des lments ActionScript interactifs 2 Crer et ajouter les boutons 3 Ecrire le code ActionScript

18
4 Test de lapplication.
Prparation lajout dinteractivit

Avant dajouter des lments interactifs lanimation, nous devons configurer le fichier FLA en crant des emplacements pour ajouter le nouveau contenu. En loccurrence, il sagit de crer un espace sur la scne o les boutons sont placs, et un espace dans le fichier FLA pour garder diffrents lments spars. Pour configurer le fichier FLA et ajouter des lments interactifs : 1 Crez un fichier FLA comportant une animation simple (une interpolation de mouvement simple ou une interpolation de forme, par exemple). Si vous disposez dj dun fichier FLA contenant lanimation que vous prsentez dans le projet, ouvrez-le et enregistrez-le sous un nouveau nom.
2 Choisissez lendroit o vous souhaitez que les deux boutons apparaissent lcran. Lun deux lance lanimation et
lautre effectue un lien vers le portfolio de lauteur ou la page daccueil. Si ncessaire, librez ou ajoutez de lespace sur la scne pour ce nouveau contenu. Le cas chant, vous pouvez crer un cran de dmarrage sur la premire image, auquel cas, dcalez lanimation afin quelle dmarre sur limage 2 ou ultrieurement.
3 Ajoutez un nouveau calque, au-dessus des autres dans le scnario, et nommez-le buttons. Il sagit du calque auquel
vous ajouterez les boutons.

4 Ajoutez un nouveau calque, au-dessus du calque buttons, et nommez-le actions. Cest l que vous ajouterez le code
ActionScript votre application.
Cration et ajout de boutons

Vous allez prsent crer et positionner les boutons qui constituent le centre de lapplication interactive. Pour crer et ajouter des boutons au fichier FLA : 1 A laide des outils de dessin, crez laspect visuel de votre premier bouton (celui de lecture) sur le calque buttons. Par exemple, dessinez un ovale horizontal avec du texte par-dessus.
2 A laide de loutil de slection, slectionnez toutes les parties graphiques du bouton. 3 Dans le menu principal, choisissez Modifier > Convertir en symbole. 4 Dans la bote de dialogue, choisissez le type de symbole de bouton, donnez-lui un nom et cliquez sur OK. 5 Le bouton tant slectionn, dans lInspecteur des proprits, affectez-lui le nom doccurrence playButton. 6 Rptez les tapes 1 5 afin de crer le bouton qui permettra lutilisateur daccder la page daccueil de lauteur.
Nommez ce bouton homeButton.
Ecriture du code
Le code ActionScript de cette application peut tre divis en trois ensembles de fonctionnalits, mme sils sont tous entrs au mme endroit. Le code doit effectuer les trois oprations suivantes :
Arrter la tte de lecture ds le chargement du fichier SWF (lorsque la tte de lecture atteint limage 1). Ecouter un vnement pour lancer la lecture du fichier SWF lorsque lutilisateur clique sur le bouton de lecture. Ecouter un vnement pour que le navigateur accde lURL approprie lorsque lutilisateur clique sur le bouton
de la page daccueil de lauteur.

19
Pour crer un code qui arrte la tte de lecture lorsquelle atteint limage 1 : 1 Slectionnez limage-cl sur limage 1 du calque actions.
2 Pour ouvrir le panneau Actions, slectionnez Fentre > Actions dans le menu principal. 3 Dans le panneau Script, entrez le code suivant :
stop();
Pour crire un code qui lance lanimation lorsque lutilisateur clique sur le bouton de lecture : 1 A la fin du code entr aux tapes prcdentes, ajoutez deux lignes vides.
2 Entrez le code suivant en bas du script :
function startMovie(event:MouseEvent):void { this.play(); }
Ce code dfinit une fonction appele startMovie(). Lorsque la fonction startMovie() est appele, elle lance la lecture du scnario principal.
3 Sur la ligne qui suit le code ajout ltape prcdente, entrez cette ligne de code :
playButton.addEventListener(MouseEvent.CLICK, startMovie);
Cette ligne de code enregistre la fonction startMovie() comme couteur de lvnement click de playButton. Ainsi, chaque fois que lutilisateur clique sur le bouton playButton, la fonction startMovie() est appele. Pour rdiger un code qui permet au navigateur daccder une URL lorsque lutilisateur clique sur le bouton de la page daccueil : 1 A la fin du code entr aux tapes prcdentes, ajoutez deux lignes vides.
2 Entrez ce code au bas du script :
function gotoAuthorPage(event:MouseEvent):void { var targetURL:URLRequest = new URLRequest("http://example.com/"); navigateToURL(targetURL); }
Ce code dfinit une fonction gotoAuthorPage(). Cette fonction cre dabord une occurrence dURLRequest reprsentant lURL http://example.com/, puis transmet cette URL la fonction navigateToURL() afin que le navigateur de lutilisateur louvre.
3 Sur la ligne qui suit le code ajout ltape prcdente, entrez cette ligne de code :
homeButton.addEventListener(MouseEvent.CLICK, gotoAuthorPage);
Cette ligne de code enregistre la fonction gotoAuthorPage() comme couteur pour lvnement click de homeButton. Ainsi, chaque fois que lutilisateur clique sur le bouton homeButton, la fonction gotoAuthorPage() est appele.
Test de lapplication
A ce stade, lapplication est entirement oprationnelle. Testons-la pour nous assurer que cest le cas. Pour tester lapplication : 1 Dans le menu principal, slectionnez Contrle > Tester lanimation. Flash Professional cre le fichier SWF et louvre dans une fentre Flash Player.

20
2 Testez les deux boutons pour vrifier quils fonctionnent. 3 Si ce nest pas le cas, vrifiez les points suivants :
Les deux boutons ont-ils des noms doccurrence diffrents ? Les appels la mthode addEventListener() utilisent-ils les mmes noms que les noms doccurrence des
boutons ?
Les noms dvnement corrects sont-ils utiliss dans les appels la mthode addEventListener() ? Le paramtre correct est-il spcifi pour chacune des fonctions (qui ncessitent toutes les deux un seul
paramtre avec le type de donnes MouseEvent) ? Tous ces points et la plupart des autres erreurs possibles entranent lapparition dun message derreur lorsque vous choisissez la commande Tester lanimation ou que vous cliquez sur le bouton pendant le test. Recherchez les erreurs de compilation dans le panneau prvu cet effet (celles qui ont lieu lorsque vous choisissez dabord Tester lanimation). Recherchez les erreurs dexcution dans le panneau Sortie. Il sagit des erreurs qui ont lieu pendant la lecture du contenu, lorsque vous cliquez sur un bouton, par exemple.
Cration dapplications avec ActionScript

La cration dune application avec ActionScript ncessite dautres connaissances que la syntaxe et les noms de classes utiliser. Bien que la documentation de la plate-forme Flash soit essentiellement axe sur ces deux sujets (la syntaxe et lutilisation des classes ActionScript), dautres informations pourront vous tre utiles :
Quels sont les programmes qui permettent dcrire du code ActionScript ? Comment ce code sorganise-t-il ? Comment sintgre-t-il une application ? Quelles tapes faut-il respecter dans le dveloppement dune application ActionScript ?
Options dorganisation du code

Le code ActionScript 3.0 peut servir gnrer de nombreuses applications, quil sagisse dune simple animation graphique ou dun systme complexe de traitement des transactions client/serveur. Selon le type dapplication envisag, choisissez lune ou plusieurs des mthodes suivantes pour intgrer ActionScript dans votre projet. Stockage du code dans les images dun scnario Flash Professional Dans Flash Professional, vous pouvez ajouter du code ActionScript toute image place dans un scnario. Ce code est excut pendant la lecture du clip, au moment o la tte de lecture atteint limage. Linsertion de code ActionScript dans des images est une manire simple dajouter des comportements des applications cres dans Flash Professional. Vous pouvez placer du code dans nimporte quelle image du scnario principal ou de celui dun symbole de clip. Cette souplesse a nanmoins un cot. Lorsque vous crez des applications assez volumineuses, vous risquez de ne plus savoir quelles images contiennent quels scripts. A terme, cela peut compliquer la maintenance de lapplication. Pour simplifier lorganisation de leur code ActionScript dans Flash Professional, de nombreux dveloppeurs placent ce code uniquement dans la premire image du scnario ou sur un calque spcifique du document Flash. Il est ainsi plus facile de retrouver et de maintenir le code dans les fichiers FLA Flash. Toutefois, la rutilisation du mme code dans un autre projet Flash Professional oblige copier et coller le code dans le nouveau fichier.

21
Si vous voulez continuer pouvoir utiliser votre code ActionScript dans de futurs projets Flash Professional, stockez ce code dans des fichiers ActionScript externes (des fichiers texte dots de lextension .as). Incorporation de code dans les fichiers Flex MXML Dans un environnement de dveloppement Flex tel que Flash Builder, vous pouvez placer le code ActionScript dans une balise <fx:Script> dans un fichier MXML Flex. Dans les projets de grande taille, cette technique se traduit nanmoins par une complexit accrue et il est plus difficile de rutiliser du code dans un autre projet Flex. Pour faciliter la rutilisation de code ActionScript dans de futurs projets Flex, stockez-le dans des fichiers ActionScript externes. Remarque : vous pouvez spcifier un paramtre source pour une balise <fx:Script>, ce qui vous permet dimporter du code ActionScript partir dun fichier externe comme sil avait t tap directement dans la balise <fx:Script>. Cependant, le fichier source que vous utilisez pour ce faire ne peut dfinir sa propre classe, ce qui limite les possibilits de rutilisation. Stockage du code dans des fichiers ActionScript Si votre projet implique une quantit importante de code ActionScript, la meilleure solution consiste stocker le code dans des fichiers source ActionScript (des fichiers texte dots de lextension .as). Un fichier ActionScript peut suivre deux structures, selon lutilisation que vous prvoyez den faire dans votre application.
Code ActionScript non structur : les lignes de code ActionScript, y compris les instructions et les dfinitions de
fonction, sont crites comme si elles taient saisies directement dans un script de scnario ou un fichier MXML. Rdig de cette faon, le code est accessible par le biais de linstruction ActionScript include ou de la balise <fx:Script> dans Flex MXML. Linstruction ActionScript include indique au compilateur dinsrer le contenu dun fichier ActionScript externe un endroit particulier dun script et sur une tendue donne, comme sil avait t saisi directement. Dans le langage MXML, la balise <fx:Script> permet de spcifier lattribut source qui identifie le fichier ActionScript externe charger cet endroit de lapplication. Par exemple, la balise suivante charge un fichier ActionScript externe appel Box.as :
<fx:Script source="Box.as" />
Dfinition dune classe ActionScript : la dfinition dune classe ActionScript ainsi que ses dfinitions de mthode
et de proprit. Lorsque vous dfinissez une classe, vous pouvez accder au code ActionScript correspondant en crant une occurrence de cette classe et en utilisant ses proprits, mthodes et vnements, comme vous le feriez avec toute classe ActionScript intgre. Cela implique deux oprations :
Utilisez linstruction import pour spcifier le nom complet de la classe, de manire ce que le compilateur
ActionScript sache o la trouver. Par exemple, pour utiliser la classe MovieClip dans ActionScript, importez cette classe laide de son nom complet, en incluant le package et la classe :
import flash.display.MovieClip;
Une autre solution consiste importer le package contenant la classe MovieClip, ce qui revient crire des instructions import pour chaque classe du package :
import flash.display.*;
Cette obligation dimporter les classes auxquelles vous faites rfrence dans votre code ne sapplique pas aux classes de niveau suprieur, qui ne sont pas dfinies dans le package.

22
Rdigez du code qui fait spcifiquement rfrence au nom de classe. Par exemple, dclarez une variable dont le
type de donnes est cette classe et crez une occurrence de la classe stocker dans la variable. Lorsque vous utilisez une classe dans le code ActionScript, vous indiquez au compilateur de charger la dfinition de cette classe. Par exemple, si lon considre une classe externe appele Box, linstruction suivante provoque la cration dune occurrence de cette classe :
var smallBox:Box = new Box(10,20);
Lorsque le compilateur rencontre pour la premire fois la rfrence la classe Box, il effectue une recherche dans le code source charg afin de trouver la dfinition de cette classe.
Choix de loutil appropri

Vous disposez de plusieurs outils ( utiliser individuellement ou en combinaison) pour lcriture et la modification du code ActionScript. Flash Builder Adobe Flash Builder est le principal outil de cration de projets avec la structure Flex ou de projets constitus en majorit de code ActionScript. Outre ses outils de prsentation visuelle et ddition MXML, Flash Builder comprend un diteur ActionScript complet, qui permet de crer des projets Flex ou ActionScript seul. Flex prsente de nombreux avantages, notamment un large ventail de commandes dinterface printgres et de commandes de disposition dynamique souples, ainsi que des mcanismes intgrs permettant de manipuler des donnes distance et de lier des donnes externes aux lments dinterface utilisateur. Toutefois, ces fonctions ncessitant davantage de code, les projets utilisant Flex se caractrisent par une taille de fichier SWF suprieure celle de leurs homologues non-Flex. Utilisez Flash Builder pour crer avec Flex, dans un seul et mme outil, des applications de donnes sur Internet riches en fonctions, tout en modifiant du code ActionScript et MXLM et en disposant les lments de manire visuelle. De nombreux utilisateurs de Flash Professional qui laborent des projets ActionScript utilisent cette application pour crer des actifs visuels et Flash Builder comme diteur du code ActionScript. Flash Professional Outre ses capacits de cration graphique et danimation, Flash Professional comprend des outils qui permettent de manipuler le code ActionScript, quil soit joint des lments dun fichier FLA ou regroup dans des fichiers ActionScript externes. Flash Professional savre idal pour les projets impliquant des animations ou vidos consquentes, ou lorsque vous dsirez crer la plupart des actifs graphiques vous-mme. Cet outil peut galement vous paratre adapt au dveloppement dun projet ActionScript si vous prfrez crer les actifs visuels et crire le code dans une seule et mme application. Flash Professional propose galement des composants dinterface utilisateur printgrs. Vous pouvez vous en servir pour rduire la taille du fichier SWF et faire appel des outils visuels pour les envelopper dans le cadre de votre projet. Flash Professional inclut deux outils permettant lcriture de code ActionScript :
Panneau Actions : disponible lorsque vous manipulez un fichier FLA, ce panneau vous permet dcrire du code
ActionScript associ aux images dun scnario.
Fentre de script : la fentre de script est un diteur de texte ddi permettant de travailler sur des fichiers de code
ActionScript (.as).

23
Editeur ActionScript tiers Les fichiers ActionScript (.as) tant stocks comme de simples fichiers texte, tout programme susceptible de modifier des fichiers texte brut peut servir crire des fichiers ActionScript. Outre les produits ActionScript dAdobe, plusieurs programmes tiers ddition de texte ont t crs avec des fonctions propres ActionScript. Vous pouvez crire un fichier MXML ou des classes ActionScript laide de tout diteur de texte. Vous pouvez ensuite crer une application laide du kit de dveloppement SDK Flex. Le projet peut utiliser Flex ou consister en une application ActionScript seul. Pour certains dveloppeurs, une autre solution consiste crire les classes ActionScript dans Flash Builder ou un diteur ActionScript tiers, en combinaison avec Flash Professional pour la cration du contenu graphique. Vous pouvez choisir un diteur ActionScript tiers dans les cas suivants :
Vous prfrez crire le code ActionScript dans un programme distinct, tout en concevant les lments visuels dans
Flash Professional.
Vous utilisez une application de programmation non ActionScript (par exemple pour la cration de pages HTML
ou llaboration dapplication dans un autre langage de programmation) et vous souhaitez vous en servir pour le code ActionScript galement.
Vous voulez crer des projets ActionScript seul ou Flex laide du kit de dveloppement SDK Flex sans Flash
Professional ou Flash Builder. Les principaux diteurs de code prenant en charge ActionScript sont les suivants :
Adobe Dreamweaver CS4 ASDT (disponible en anglais uniquement) FDT (disponible en anglais uniquement) FlashDevelop (disponible en anglais uniquement) PrimalScript (disponible en anglais uniquement) SE|PY(disponible en anglais uniquement) TextMate (intgrant ActionScript et Flex)
Processus de dveloppement ActionScript

Quelle que soit la taille de votre projet ActionScript, lutilisation dun processus de conception et de dveloppement vous aidera travailler plus efficacement. Les tapes ci-aprs forment le processus de dveloppement de base pour la conception dune application avec ActionScript 3.0 :
1 Concevez votre application.
Avant de commencer construire votre application, dcrivez-la dune manire ou dune autre.
2 Composez votre code ActionScript 3.0.
Vous pouvez crer du code ActionScript dans Flash Professional, Flash Builder, Dreamweaver ou un diteur de texte.
3 Crez un projet Flash ou Flex pour excuter votre code.
Dans Flash Professional, crez un fichier FLA, dfinissez les paramtres de publication, ajoutez des composants dinterface utilisateur lapplication et rfrencez le code ActionScript. Dans Flex, dfinissez lapplication et ajoutez des composants dinterface utilisateur laide de MXML, puis rfrencez le code ActionScript.
4 Publiez et testez lapplication ActionScript.
A cet effet, excutez-la au sein de lenvironnement de dveloppement et vrifiez quelle effectue toutes les oprations voulues.

24
Il nest pas indispensable de suivre ces tapes dans cet ordre ou dachever lune delles avant de passer la suivante. Par exemple, vous pouvez concevoir un cran de lapplication (tape 1), puis crer les graphiques, boutons, etc. (tape 3), avant dcrire le code ActionScript (tape 2) et de le tester (tape 4). Vous pouvez tout aussi bien concevoir une partie de lcran, puis ajouter un bouton ou un lment dinterface la fois, crire le code ActionScript correspondant et le tester ds quil est prt. Bien quil soit judicieux de garder lesprit ces quatre stades du processus de dveloppement, il est en pratique plus efficace daller et venir entre ces tapes en fonction des besoins.
Cration de vos propres classes

Le processus de cration des classes destines vos projets peut paratre rbarbatif. Cependant, la partie la plus difficile de la cration dune classe est la conception de ses mthodes, proprits et vnements.
Stratgies de conception dune classe

La conception oriente objet est un sujet complexe ; des carrires entires ont t consacres ltude acadmique et la pratique professionnelle de cette discipline. Voici tout de mme quelques suggestions dapproches qui vous aideront lancer votre projet.
1 Rflchissez au rle que jouent les occurrences de la classe dans lapplication. En rgle gnrale, les objets servent
lun des objectifs suivants :
Objet de valeur : ces objets constituent avant tout des conteneurs de donnes, cest--dire quils possdent
probablement plusieurs proprits et peu de mthodes (parfois aucune). Il sagit en gnral dune reprsentation dans le code dlments clairement dfinis, tels quune classe Song (reprsentant une seule chanson) ou une classe Playlist (reprsentant un groupe conceptuel de chansons) dans une application musicale.
Objet daffichage : ce type correspond des objets qui saffichent rellement lcran, par exemple des lments
dinterface, tels que des listes droulantes ou des libells dtat, des lments graphiques tels que des cratures dans un jeu vido, etc.
Structure dapplication : ces objets jouent un large ventail de rles dans la logique ou le traitement effectu par
les applications. Il sagit par exemple dun objet ralisant des calculs dans une simulation de biologie, un objet charg de synchroniser les valeurs entre une commande physique et le volume de sortie dune application musicale, un objet qui gre les rgles dun jeu vido ou une classe qui charge une image enregistre dans une application de dessin.
2 Dcidez de la fonctionnalit requise pour la classe. Les diffrentes fonctionnalits constituent souvent les mthodes
de la classe.
3 Si la classe est destine servir dobjet de valeur, choisissez les donnes inclues dans les occurrences. Ces lments
peuvent facilement devenir des proprits.

4 Puisque vous concevez la classe spcialement pour votre projet, le plus important est que vous tablissiez la
fonctionnalit ncessaire votre application. Pour vous aider, vous pouvez rpondre ces questions :
Quel type dinformations lapplication stocke, surveille et manipule-t-elle ? Vous pourrez alors identifier les
objets de valeurs et les proprits ncessaires.
Quels jeux dactions doivent tre excuts, par exemple lors du premier chargement de lapplication, lorsque
lutilisateur clique sur un bouton donn, lorsque la lecture dun clip sarrte, etc. ? Ces lments constituent souvent des mthodes ou des proprits, si les actions consistent modifier des valeurs isoles.
Pour chaque action considre, quelles informations sont ncessaires pour son excution ? Ces lments
deviennent les paramtres de la mthode.

25
Pendant le fonctionnement de lapplication, quelles modifications, qui doivent tre communiques dautres
parties de lapplication, surviennent dans la classe ? Ces lments forment en gnral des vnements.
5 Si un objet existant est semblable lobjet dont vous avez besoin mais quil lui manque certaines fonctionnalits que
vous souhaitez ajouter, envisagez de crer une sous-classe (c.--d. une classe qui repose sur la fonctionnalit dune classe existante et dont il nest pas ncessaire de dfinir la fonctionnalit propre). Par exemple, pour crer une classe correspondant un objet affich lcran, appuyez-vous sur le comportement de lun des objets daffichage existants (MovieClip ou Sprite, par exemple), qui constituerait alors la classe de base, que votre classe viendrait tendre.
Ecriture du code dune classe

Une fois que vous avez conu votre classe ou au moins identifi les informations quelle manipulera et les actions quelle devra effectuer, lcriture et la syntaxe utiliser sont relativement simples. Voici la procdure minimale de cration dune classe ActionScript :
1 Ouvrez un nouveau document texte dans un diteur de texte ActionScript. 2 Saisissez une instruction class afin de dfinir le nom de la classe. Pour ce faire, entrez les mots public class puis
le nom de la classe, suivi dune paire daccolades qui entoureront le contenu de la classe (les dfinitions de mthode et de proprit). Exemple :
public class MyClass { }
Le mot public indique que la classe est accessible par tout autre code. Pour dautres possibilits, voir Attributs despace de noms de contrle daccs.
3 Entrez une instruction package pour indiquer le nom du package contenant votre classe. La syntaxe est le mot
package, suivi du nom complet du package, puis dune paire daccolades (qui entourent llment structurel class). Par exemple, modifiez le code prcdent comme suit : package mypackage { public class MyClass { } }
4 Dfinissez chaque proprit de la classe laide de linstruction var ajoute dans le corps de la classe. Utilisez la
mme syntaxe que pour la dclaration dune variable (en y ajoutant le qualificatif public). Par exemple, les lignes suivantes ajoutes entre les accolades de la dfinition de classe permettent de crer des proprits appeles textProperty, numericProperty et dateProperty :
public var textProperty:String = "some default value"; public var numericProperty:Number = 17; public var dateProperty:Date;
5 Dfinissez chaque mthode de la classe laide de la syntaxe utilise pour dfinir une fonction. Exemple :
Pour crer la mthode myMethod(), saisissez :

public function myMethod(param1:String, param2:Number):void { // do something with parameters }

26
Pour crer un constructeur (une mthode spciale appele pendant la cration dune occurrence de classe), crez
une mthode dont le nom correspond exactement au nom de la classe :
public function MyClass() { // do stuff to set initial values for properties // and otherwise set up the object textVariable = "Hello there!"; dateVariable = new Date(2001, 5, 11); }
Si vous nincluez pas de mthode constructeur dans votre classe, le compilateur cre automatiquement un constructeur vide (sans paramtres ni instructions) dans la classe. Il est possible de dfinir dautres lments de classe, mais avec plus dimplication.
Les accesseurs constituent un croisement spcial entre une mthode et une proprit. Lorsque vous rdigez le
code de dfinition dune classe, laccesseur scrit comme une mthode. Vous pouvez ainsi accomplir plusieurs actions, et pas seulement la lecture ou lattribution dune valeur, seules actions disponibles lors de la dfinition dune proprit. Toutefois, lorsque vous crez une occurrence de la classe, vous traitez laccesseur comme une proprit et utilisez son nom pour lire ou attribuer la valeur.
Dans ActionScript, les vnements ne sont pas dfinis laide dune syntaxe spcifique. Pour dfinir les
vnements de la classe, vous utilisez la fonctionnalit de la classe EventDispatcher.
Voir aussi
Gestion des vnements
Exemple : Cration dune application de base

ActionScript 3.0 peut sutiliser dans divers environnements de dveloppement dapplication, notamment les outils Flash Professional et Flash Builder, ou tout diteur de texte. Cet exemple dcrit les diffrentes tapes de la cration et de lamlioration dune application ActionScript 3.0 simple laide de Flash Professional ou de Flash Builder. Lapplication laborer prsente une manire simple dutiliser les fichiers de classe externes ActionScript 3.0 dans Flash Professional et Flex.
Conception dune application ActionScript

Cet exemple dapplication ActionScript est une application standard de salutation, du type Hello World. Sa conception est donc trs simple :
Lapplication se nomme HelloWorld. Elle affiche un seul champ de texte contenant les mots Hello World! . Elle utilise une seule classe oriente objet, appele Greeter, qui, de par sa conception, pourra tre exploite dans un
projet Flash Professional ou Flex.
Une fois la version de base de lapplication cre, vous ajouterez dautres fonctionnalits, pour inviter lutilisateur
saisir son nom et comparer ce nom une liste dutilisateurs reconnus. Cette dfinition bien tablie, vous pouvez commencer crer lapplication elle-mme.

27
Cration du projet HelloWorld et de la classe Greeter

Selon les dcisions de conception, le code de lapplication HelloWorld doit tre facilement rutilisable. Pour satisfaire cette exigence, lapplication utilise une seule classe oriente objet, appele Greeter, qui est exploite au sein dune application que vous crez dans Flash Builder ou Flash Professional. Pour crer le projet HelloWorld et la classe Greeter dans Flex : 1 Dans Flash Builder, slectionnez File > New > Flex Project.
2 Attribuez le nom Hello World au projet. Vrifiez que le type dapplication correspond Web (runs in Adobe
Flash Player) , puis cliquez sur Finish. Flash Builder cre le projet et laffiche dans lExplorateur de packages. Par dfaut, le projet contient un fichier nomm HelloWorld.mxml, qui est ouvert dans lditeur.
3 Pour crer un fichier de classe ActionScript personnalis dans Flash Builder, slectionnez File > New >
ActionScript Class.
4 Dans le champ Name de la bote de dialogue New ActionScript Class, saisissez le nom de classe Greeter, puis
cliquez sur Finish. Une nouvelle fentre de modification ActionScript saffiche. Passez maintenant la section Ajout de code la classe Greeter. Pour crer la classe Greeter dans Flash Professional : 1 Dans Flash Professional, slectionnez Fichier > Nouveau.
2 Dans la bote de dialogue Nouveau document, slectionnez un fichier ActionScript et cliquez sur OK.
Une nouvelle fentre de modification ActionScript saffiche.

3 Choisissez Fichier > Enregistrer. Slectionnez un dossier pour votre application, nommez le fichier ActionScript
Greeter.as, puis cliquez sur OK. Passez maintenant la section Ajout de code la classe Greeter.
Ajout de code la classe Greeter

La classe Greeter dfinit un objet, Greeter, que vous utilisez dans lapplication HelloWorld. Pour ajouter du code la classe Greeter : 1 Saisissez le code suivant (susceptible davoir t partiellement entr votre intention) dans le nouveau fichier :
package { public class Greeter { public function sayHello():String { var greeting:String; greeting = "Hello World!"; return greeting; } } }
La classe Greeter comporte une mthode unique, sayHello(), qui renvoie la chane Hello World! .

28
2 Slectionnez Fichier > Enregistrer pour enregistrer ce fichier ActionScript.
La classe Greeter peut maintenant tre utilise dans une application.
Cration dune application utilisant votre code ActionScript

La classe Greeter que vous avez cre dfinit un ensemble autonome de fonctions logicielles, mais ne constitue pas pour autant une application complte. Pour lutiliser, vous crez un projet Flash Professional ou Flex. Le code requiert une occurrence de la classe Greeter. La procdure dassociation de la classe Greeter lapplication est la suivante. Pour crer une application ActionScript laide de Flash Professional : 1 Choisissez Fichier > Nouveau.
2 Dans la bote de dialogue document, slectionnez Fichier Flash (ActionScript 3.0) et cliquez sur OK.
Une nouvelle fentre de document saffiche.

3 Choisissez Fichier > Enregistrer. Slectionnez le mme dossier qui contient le fichier de classe Greeter.as, nommez
le document Flash HelloWorld.fla, puis cliquez sur OK.

4 Dans la palette des outils de Flash Professional, slectionnez loutil Texte et faites-le glisser sur la scne pour dfinir
un nouveau champ de texte denviron 300 pixels de largeur et 100 pixels de hauteur.
5 Le champ de texte tant slectionn sur la scne, dans le panneau Proprits, dfinissez le type de texte sur Texte
dynamique et tapez mainText comme nom doccurrence du champ de texte.

6 Cliquez sur la premire image du scnario principal. Slectionnez Fentre > Actions pour ouvrir le panneau
Actions.
7 Dans le panneau Actions, tapez le script suivant :
var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello();
8 Enregistrez le fichier.
Passez maintenant la section Publication et test de votre application ActionScript. Pour crer une application ActionScript laide de Flash Builder : 1 Ouvrez le fichier HelloWorld.mxml et ajoutez le code illustr ci-dessous :

29
<?xml version="1.0" encoding="utf-8"?> <s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/halo" minWidth="1024" minHeight="768"" creationComplete="initApp()"> <fx:Script> <![CDATA[ private var myGreeter:Greeter = new Greeter(); public function initApp():void { // says hello at the start, and asks for the user's name mainTxt.text = myGreeter.sayHello(); } ]]> </fx:Script> <s:layout> <s:VerticalLayout/> </s:layout> <s:TextArea id="mainTxt" width="400"/> </s:Application>
Le projet Flex comprend quatre balises MXML :
Une balise <s:Application>, qui dfinit le conteneur Application Une balise <s:layout>, qui dfinit le style de formatage (formatage vertical) de la balise Application Une balise <fx:Script>, qui contient du code ActionScript Une balise <s:TextArea>, qui dfinit un champ daffichage des messages texte destins lutilisateur
Le code qui figure dans la balise <fx:Script> dfinit une mthode initApp() qui est appele au chargement de lapplication. La mthode initApp() dfinit la valeur du texte de mainTxt TextArea sur la chane Hello World! renvoye par la mthode sayHello() de la classe personnalise Greeter, que vous venez de crer.
2 Slectionnez Fichier > Enregistrer pour enregistrer le fichier.
Passez maintenant la section Publication et test de votre application ActionScript.
Publication et test de votre application ActionScript

Le dveloppement logiciel est un processus itratif. Vous crivez du code, essayez de le compiler, puis modifiez ce code jusqu ce que la compilation soit russie. Vous excutez, puis testez lapplication compile, pour voir si elle rpond aux intentions de conception. Si ce nest pas le cas, vous modifiez nouveau le code, jusqu obtenir satisfaction. Les environnements de dveloppement Flash Professional et Flash Builder permettent de publier, tester et dboguer les applications de plusieurs manires. Voici une liste de base des tapes de test de lapplication HelloWorld dans chacun de ces environnements.

30
Pour publier et tester une application ActionScript laide de Flash Professional : 1 Publiez lapplication et recherchez les erreurs de compilation. Dans Flash Professional, slectionnez Contrle > Tester lanimation pour compiler le code ActionScript et excuter lapplication HelloWorld.
2 Si des erreurs ou des avertissements saffichent dans la fentre Sortie lorsque vous testez l application, rsolvez-les
dans les fichiers HelloWorld.fla ou HelloWorld.as, puis ressayez de tester lapplication.

3 Sil nexiste aucune erreur de compilation, une fentre Flash Player affiche lapplication HelloWorld.
Vous avez cr une application oriente objet, simple mais complte, qui utilise ActionScript 3.0. Passez maintenant la section Amlioration de lapplication HelloWorld. Pour publier et tester une application ActionScript laide de Flash Builder : 1 Slectionnez Run > Run HelloWorld.
2 Lapplication HelloWorld dmarre.
Si des erreurs ou des avertissements saffichent dans la fentre de sortie lorsque vous testez l application,
rsolvez-les dans les fichiers HelloWorld.mxml ou Greeter.as, puis ressayez de tester lapplication.
En labsence derreurs de compilation, une fentre de navigateur contenant lapplication HelloWorld apparat.
Elle devrait afficher le texte Hello World! Vous avez cr une application oriente objet, simple mais complte, qui utilise ActionScript 3.0. Passez maintenant la section Amlioration de lapplication HelloWorld.
Amlioration de lapplication HelloWorld

Pour rendre lapplication un peu plus attrayante, vous allez maintenant faire en sorte quelle demande le nom de lutilisateur et le compare une liste prdfinie de noms. Tout dabord, vous devez mettre jour la classe Greeter de manire ajouter cette fonctionnalit. Vous devez ensuite mettre jour lapplication afin dexploiter cette fonctionnalit. Pour mettre jour le fichier Greeter.as : 1 Ouvrez le fichier Greeter.as.
2 Remplacez son contenu par le suivant (les lignes nouvelles et modifies sont signales en gras) :

31
package { public class Greeter { /** * Defines the names that receive a proper greeting. */ public static var validNames:Array = ["Sammy", "Frank", "Dean"]; /** * Builds a greeting string using the given name. */ public function sayHello(userName:String = ""):String { var greeting:String; if (userName == "") { greeting = "Hello. Please type your user name, and then press " + "the Enter key."; } else if (validName(userName)) { greeting = "Hello, " + userName + "."; } else { greeting = "Sorry " + userName + ", you are not on the list."; } return greeting; } /** * Checks whether a name is in the validNames list. */ public static function validName(inputName:String = ""):Boolean { if (validNames.indexOf(inputName) > -1) { return true; } else { return false; } } } }
La classe Greeter prsente maintenant plusieurs fonctions nouvelles :
Le tableau validNames rpertorie les noms dutilisateur valables. Lors du chargement de la classe Greeter, ce
tableau contient trois noms.

32
La mthode sayHello() accepte dsormais un nom dutilisateur et modifie la salutation en fonction de certaines
conditions. Si le nom dutilisateur userName est une chane vide (""), la proprit greeting permet de demander le nom de lutilisateur. Si le nom dutilisateur est valable, la salutation devient "Hello, userName". Enfin, si lune de ces deux conditions nest pas satisfaite, la variable greeting renvoie la valeur "Sorry, userName, you are not on the list." (Dsol, nom dutilisateur, vous ntes pas sur la liste).
La mthode validName() renvoie la valeur true si le nom entr inputName figure dans le tableau validNames, et
la valeur false sil ne sy trouve pas. Linstruction validNames.indexOf(inputName) compare toutes les chanes du tableau validNames la chane inputName. La mthode Array.indexOf() renvoie la position dindex de la premire occurrence dun objet dans un tableau ou la valeur -1 si lobjet ne sy trouve pas. Ensuite, vous devez modifier le fichier dapplication qui rfrence cette classe ActionScript. Pour modifier lapplication laide de Flash Professional : 1 Ouvrez le fichier HelloWorld.fla.
2 Modifiez le script dans limage 1 de faon ce quune chane vide ("") soit transmise la mthode sayHello() de
la classe Greeter :
var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello("");
3 Slectionnez loutil Texte dans la palette des outils, puis crez deux champs de texte sur la scne, lun ct de
lautre, et directement sous le champ de texte mainText existant.

4 Dans le premier nouveau champ de texte, tapez le texte User Name: qui servira dtiquette. 5 Slectionnez lautre nouveau champ de texte et, dans lInspecteur des proprits, slectionnez Saisie de texte comme
type de champ de texte. Slectionnez le type de ligne Une seule ligne. Tapez textIn comme nom doccurrence.
6 Cliquez sur la premire image du scnario principal. 7 Dans le panneau Actions, ajoutez les lignes suivantes la fin du script existant :
mainText.border = true; textIn.border = true; textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed); function keyPressed(event:KeyboardEvent):void { if (event.keyCode == Keyboard.ENTER) { mainText.text = myGreeter.sayHello(textIn.text); } }
Le nouveau code ajoute la fonctionnalit suivante :
Les deux premires lignes dfinissent les bordures de deux champs de texte. Un champ de texte dentre tel que le champ textIn a un ensemble dvnements quil peut envoyer. La
mthode addEventListener() vous permet de dfinir une fonction excute lorsquun type dvnement se produit. Dans ce cas, cet vnement est le fait dappuyer sur une touche du clavier.
La fonction personnalise keyPressed() vrifie si la touche actionne est la touche Entre. Si tel est le cas, elle
appelle la mthode sayHello() de lobjet myGreeter, en transmettant le texte du champ de texte textIn comme paramtre. Cette mthode renvoie une chane greeting en fonction de la valeur transmise. La chane renvoye est ensuite affecte la proprit text du champ de texte mainText.

33
Le script complet pour limage 1 est le suivant :

var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello(""); mainText.border = true; textIn.border = true; textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed); function keyPressed(event:KeyboardEvent):void { if (event.keyCode == Keyboard.ENTER) { mainText.text = myGreeter.sayHello(textIn.text); } }
8 Enregistrez le fichier. 9 Choisissez Contrle > Tester lanimation pour excuter lapplication.
Lorsque vous excutez lapplication, il vous est demand dentrer un nom dutilisateur. Sil est valide (Sammy, Frank, ou Dean), lapplication affiche le message de confirmation hello . Pour modifier lapplication laide de Flash Builder : 1 Ouvrez le fichier HelloWorld.mxml.
2 Modifiez ensuite la balise <mx:TextArea> pour indiquer lutilisateur quelle est utilise des fins daffichage
uniquement. Choisissez un arrire-plan gris clair et dfinissez lattribut editablesur false :

<s:TextArea id="mainTxt" width="400" backgroundColor="#DDDDDD" editable="false" />
3 Ajoutez prsent les lignes suivantes juste aprs la balise de fin de <s:TextArea>. Ces lignes crent un composant
TextInput qui permet lutilisateur de saisir un nom dutilisateur :

<s:HGroup width="400"> <mx:Label text="User Name:"/> <s:TextInput id="userNameTxt" width="100%" enter="mainTxt.text = myGreeter.sayHello(userNameTxt.text);" /> </s:HGroup>
Lattribut enter dfinit laction excute lorsque lutilisateur appuie sur la touche Entre dans le champ userNameTxt. Dans cet exemple, le code transmet le texte du champ la mthode Greeter.sayHello(). Le contenu du champ mainTxt est modifi en consquence. Le fichier HelloWorld.mxml se prsente comme suit :

34
<?xml version="1.0" encoding="utf-8"?> <s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/halo" minWidth="1024" minHeight="768"" creationComplete="initApp()"> <fx:Script> <![CDATA[ private var myGreeter:Greeter = new Greeter(); public function initApp():void { // says hello at the start, and asks for the user's name mainTxt.text = myGreeter.sayHello(); } ]]> </fx:Script> <s:layout> <s:VerticalLayout/> </s:layout> <s:TextArea id="mainTxt" width="400" backgroundColor="#DDDDDD" editable="false"/> <s:HGroup width="400"> <mx:Label text="User Name:"/> <s:TextInput id="userNameTxt" width="100%" enter="mainTxt.text = myGreeter.sayHello(userNameTxt.text);" /> </s:HGroup> </s:Application>
4 Enregistrez le fichier HelloWorld.mxml modifi. Slectionnez Run > Run HelloWorld pour excuter lapplication.
Lorsque vous excutez lapplication, il vous est demand dentrer un nom dutilisateur. Sil est valide (Sammy, Frank, ou Dean), lapplication affiche le message de confirmation Hello, userName .
35
Chapitre 3 : Syntaxe et langage ActionScript

ActionScript 3.0 comprend le langage ActionScript de base et linterface de programmation dapplications (API) de la plate-forme Adobe Flash. Le langage de base correspond la partie dActionScript qui dfinit la syntaxe du langage, ainsi que les types de donnes de plus haut niveau. ActionScript 3.0 fournit un accs par programmation aux moteurs dexcution de la plate-forme Adobe Flash : Adobe Flash Player et Adobe AIR.
Prsentation du langage
Les objets sont au centre du langage ActionScript 3.0 : ils constituent ses lments fondamentaux. Chaque variable que vous dclarez, chaque fonction que vous crivez et chaque occurrence de classe que vous crez est un objet. Un programme ActionScript 3.0 peut tre compar un groupe dobjets qui effectuent des tches, rpondent des vnements et communiquent entre eux. Les programmeurs qui connaissent la programmation oriente objets en langage Java ou C++ assimilent peut-tre les objets des modules contenant deux sortes de membres : les donnes stockes dans des variables ou des proprits de membres et le comportement accessible par le biais de mthodes. ActionScript 3.0 dfinit les objets de manire similaire, mais lgrement diffrente. Dans ActionScript 3.0, les objets ne sont que des collections de proprits. Ces proprits sont des conteneurs pouvant contenir non seulement des donnes, mais galement des fonctions ou dautres objets. Si une fonction est associe un objet de cette faon, il sagit dune mthode. Alors quen thorie, la dfinition dActionScript 3.0 peut paratre un peu trange aux programmeurs ayant lhabitude dutiliser le langage Java ou C++, en pratique, la dfinition de types dobjets avec des classes ActionScript 3.0 est trs semblable la faon dont les classes sont dfinies dans Java ou C++. Il est important de distinguer les deux dfinitions dobjet lors de la prsentation du modle dobjet ActionScript et dautres rubriques plus techniques, mais gnralement, le terme proprits fait rfrence des variables de membre de classe, par opposition aux mthodes. Dans le manuel Guide de rfrence ActionScript 3.0 pour la plate-forme Adobe Flash, par exemple, le terme proprits signifie variables ou proprits de lecture et de dfinition. Il utilise le terme mthodes pour des fonctions faisant partie dune classe. Une lgre diffrence entre les classes dans ActionScript et les classes dans Java ou C++ rside dans le fait que dans ActionScript, elles ne sont pas que des entits abstraites. Les classes ActionScript sont reprsentes par des objets de classe qui stockent les mthodes et les proprits de la classe. Ainsi, des techniques pouvant sembler tranges pour les programmeurs de Java et C++ comme linsertion dinstructions ou de code excutable au niveau suprieur dune classe ou dun package sont autorises. Une autre diffrence entre les classes ActionScript et les classes Java ou C++ rside dans le fait que chaque classe ActionScript possde un objet prototype. Dans les versions prcdentes dActionScript, les objets prototypes, lis les uns aux autres en chanes de prototypes, servaient de base lensemble de la hirarchie dhritage de classe. Dans ActionScript 3.0, nanmoins, les objets prototypes ne jouent quun rle mineur dans le systme dhritage. Cependant, lobjet prototype peut toujours tre utile comme solution de rechange aux mthodes et aux proprits statiques si vous souhaitez partager une proprit et sa valeur parmi toutes les occurrences dune classe.

Syntaxe et langage ActionScript
36
Auparavant, les programmeurs ActionScript expriments pouvaient manipuler directement la chane de prototypes avec des lments de langage intgrs spciaux. Maintenant que le langage fournit une implmentation plus avance dune interface de programmation base sur des classes, un grand nombre de ces lments de langage spciaux (__proto__ et __resolve,, par exemple) ne font plus partie du langage. De plus, les optimisations du mcanisme dhritage interne qui amliorent nettement les performances empchent daccder directement au mcanisme.
Objets et classes
Dans ActionScript 3.0, chaque objet est dfini par une classe. Une classe peut tre considre comme un modle pour un type dobjet. Les dfinitions de classe peuvent inclure des variables et des constantes, qui comprennent des valeurs de donnes, et des mthodes, qui sont des fonctions encapsulant le comportement li la classe. Les valeurs stockes dans les proprits peuvent tre des valeurs primitives ou dautres objets. Les valeurs primitives sont des nombres, des chanes ou des valeurs boolennes. ActionScript contient de nombreuses classes intgres faisant partie du langage de base. Certaines de ces classes intgres (Number, Boolean et String, par exemple), reprsentent les valeurs primitives disponibles dans ActionScript. Dautres, telles que les classe Array, Math et XML, dfinissent des objets plus complexes. Toutes les classes, quelles soient intgres ou dfinies par lutilisateur, drivent de la classe Object. Pour les programmeurs ayant une exprience avec ActionScript, il est important de noter que le type de donnes Object nest plus le type de donnes par dfaut, mme si toutes les autres classes en drivent. Dans ActionScript 2.0, les deux lignes de code suivantes taient quivalentes car labsence dune annotation de type signifiait quune variable aurait t de type Object :
var someObj:Object; var someObj;
ActionScript 3.0, nanmoins, prsente le concept de variables non types, qui peuvent tre dsignes des deux faons suivantes :
var someObj:*; var someObj;
Une variable non type est diffrente dune variable de type Object. La diffrence majeure est que les variables non types peuvent contenir la valeur spciale undefined, alors quune variable de type Object ne le peut pas. Vous pouvez dfinir vos propres classes laide du mot-cl class. Vous disposez de trois faons diffrentes pour dclarer les proprits dune classe : vous pouvez dfinir des constantes avec le mot-cl const, des variables avec le mot-cl var et des proprits de lecture et de dfinition au moyen des attributs get et set dans une dclaration de mthode. Vous pouvez dclarer des mthodes avec le mot-cl function. Vous crez une occurrence dune classe laide de loprateur new. Lexemple suivant cre une occurrence de la classe Date appele myBirthday.
var myBirthday:Date = new Date();

37
Packages et espaces de noms

Les packages et les espaces de noms sont des concepts associs. Les packages vous permettent de regrouper des dfinitions de classe de faon faciliter le partage de code et rduire les conflits de noms. Les espaces de noms vous permettent de contrler la visibilit des identifiants (noms de mthode et de proprit, par exemple) et peuvent tre appliqus un code se trouvant lintrieur ou lextrieur dun package. Utilisez des packages pour organiser vos fichiers de classe et des espaces de noms pour grer la visibilit des mthodes et des proprits individuelles.
Packages
Les packages dans ActionScript 3.0 sont implments avec des espaces de noms, mais ils ne sont pas synonymes. Lorsque vous dclarez un package, vous crez implicitement un type despace de noms spcial qui est sr dtre connu lors de la compilation. Les espaces de noms, lorsque vous les crez explicitement, ne sont pas ncessairement connus au moment de la compilation. Lexemple suivant utilise la directive package pour crer un simple package contenant une classe :
package samples { public class SampleCode { public var sampleGreeting:String; public function sampleFunction() { trace(sampleGreeting + " from sampleFunction()"); } } }
Le nom de la classe dans cet exemple est SampleCode. Etant donn que la classe se trouve lintrieur du package samples, le compilateur qualifie automatiquement le nom de classe lors de la compilation sous la forme de son nom qualifi : samples.SampleCode. Le compilateur qualifie galement les noms des proprits ou des mthodes, de sorte que sampleGreeting et sampleFunction() deviennent respectivement samples.SampleCode.sampleGreeting et samples.SampleCode.sampleFunction(). Un grand nombre de dveloppeurs (notamment ceux ayant une exprience de programmation Java) placent uniquement des classes au niveau suprieur dun package. ActionScript 3.0, cependant, prend non seulement en charge des classes au niveau suprieur dun package, mais galement des variables, des fonctions et mme des instructions. Une utilisation avance de cette fonction consiste dfinir un espace de noms au niveau suprieur dun package de faon ce que toutes les classes contenues dans ce dernier puissent lutiliser. Il convient nanmoins de noter que seuls deux spcificateurs daccs, public et internal, sont autoriss au niveau suprieur dun package. Contrairement Java qui permet de dclarer des classes imbriques prives, ActionScript 3.0 ne prend en charge ni les classes imbriques, ni les classes prives. Nanmoins, les packages ActionScript 3.0 et les packages du langage de programmation Java prsentent dautres ressemblances. Comme vous pouvez lobserver dans lexemple prcdent, les rfrences de package entirement qualifies sont exprimes laide de loprateur point (.), comme dans Java. Vous pouvez utiliser des packages pour organiser votre code dans une structure hirarchique intuitive que dautres programmeurs peuvent utiliser. Ceci facilite le partage de code en vous permettant de crer votre propre package et de le partager avec dautres personnes, et dutiliser des packages crs par dautres personnes dans votre code.

38
Lutilisation de packages vous permet galement de vrifier que les noms didentifiant que vous utilisez sont uniques et quils ne sont pas incompatibles avec dautres noms didentifiant. Pour certaines personnes, il sagit dailleurs de lavantage principal des packages. Par exemple, deux programmeurs qui souhaitent partager leur code peuvent chacun avoir cr une classe appele SampleCode. Sans packages, il y aurait un conflit de noms, et la seule faon de rsoudre le problme serait de renommer lune des classes. Mais avec des packages, vous pouvez viter le conflit de noms en plaant lune des classes (ou de prfrence les deux) dans des packages avec des noms uniques. Vous pouvez galement inclure des points intgrs dans le nom de votre package afin de crer des packages imbriqus. Ceci vous permet de crer une organisation hirarchique des packages. Le package flash.display, fourni par ActionScript 3.0, en est un bon exemple. Il est imbriqu au sein du package flash. La majeure partie dActionScript 3.0 se trouve dans le package flash. Par exemple, le package flash.display contient lAPI de la liste daffichage, et le package flash.events contient le nouveau modle dvnement.
Cration de packages
ActionScript 3.0 vous permet dorganiser vos packages, classes et fichiers source avec une grande souplesse. Les versions prcdentes dActionScript autorisaient uniquement une classe par fichier source et exigeaient que le nom du fichier source corresponde au nom de la classe. ActionScript 3.0 vous permet dinclure plusieurs classes dans un fichier source, mais une seule classe dans chaque fichier peut tre utilise par le code externe ce fichier. En dautres termes, une seule classe dans chaque fichier peut tre dclare lintrieur dune dclaration de package. Vous devez dclarer toute classe supplmentaire lextrieur de votre dfinition de package. Elles sont alors invisibles pour le code externe ce fichier source. Le nom de la classe dclare lintrieur de la dfinition de package doit correspondre au nom du fichier source. ActionScript 3.0 permet galement de dclarer des packages avec davantage de flexibilit. Dans les versions prcdentes dActionScript, les packages reprsentaient simplement des rpertoires dans lesquels vous placiez des fichiers source, et vous ne dclariez pas les packages avec linstruction package mais incluiez plutt le nom du package dans le nom de classe complet dans votre dclaration de classe. Mme si les packages continuent reprsenter des rpertoires dans ActionScript 3.0, leur contenu nest pas limit aux seules classes. Dans ActionScript 3.0, vous utilisez linstruction package pour dclarer un package, ce qui signifie que vous pouvez galement dclarer des variables, des fonctions et des espaces de noms au niveau suprieur dun package. Vous pouvez galement y inclure des instructions excutables. Si vous dclarez des variables, des fonctions ou des espaces de noms ce niveau, les seuls attributs disponibles sont public et internal, et une seule dclaration au niveau du package par fichier peut utiliser lattribut public, que cette dclaration soit une classe, une variable, une fonction ou un espace de noms. Les packages sont utiles pour organiser votre code et viter les conflits de noms. Vous ne devez pas confondre le concept de packages avec le concept distinct dhritage de classe. Deux classes se trouvant dans un mme package ont un espace de noms en commun mais elles ne sont pas ncessairement lies lune lautre. De mme, il se peut quun package imbriqu nait aucun lien smantique avec son package parent.
Importation de packages
Si vous souhaitez utiliser une classe se trouvant lintrieur dun package, vous devez importer soit le package soit la classe en question. Ceci diffre dActionScript 2.0 o limportation de classes tait facultative. Par exemple, revenons lexemple de classe SampleCode prsent prcdemment. Si la classe se trouve dans un package appel samples, vous devez utiliser lune des instructions dimportation suivantes avant dutiliser la classe SampleCode :
import samples.*;
ou

39
import samples.SampleCode;
En gnral, les instructions import doivent tre aussi spcifiques que possible. Si vous envisagez dutiliser uniquement la classe SampleCode issue du package samples, importez uniquement la classe SampleCode au lieu du package entier auquel elle appartient. Limportation des packages entiers peut provoquer des conflits de noms inattendus. Vous devez galement placer le code source qui dfinit le package ou la classe dans votre chemin de classe. Le chemin de classe est une liste dfinie par lutilisateur de chemins de rpertoire locaux qui dtermine lendroit o le compilateur recherche des classes et des packages imports. Le chemin de classe est parfois appel chemin de cration ou chemin source. Une fois que vous avez import correctement la classe ou le package, vous pouvez utiliser le nom entirement qualifi de la classe (samples.SampleCode) ou simplement le nom de la classe (SampleCode). Les noms entirement qualifis sont utiles lorsque des classes, des mthodes ou des proprits ayant le mme nom gnrent un code ambigu mais ils peuvent tre difficiles grer si vous les utilisez pour tous les identifiants. Par exemple, lutilisation du nom entirement qualifi gnre un code dtaill lorsque vous instanciez une occurrence de classe SampleCode :
var mySample:samples.SampleCode = new samples.SampleCode();
Plus les niveaux de packages imbriqus augmentent, moins votre code est lisible. Lorsque vous pensez que des identifiants ambigus ne sont pas un problme, vous pouvez rendre votre code plus lisible en utilisant des identifiants simples. Par exemple, linstanciation dune nouvelle occurrence de la classe SampleCode est beaucoup moins longue si vous utilisez uniquement lidentifiant de classe :
var mySample:SampleCode = new SampleCode();
Si vous tentez dutiliser des noms didentifiant sans importer au pralable la classe ou le package appropri, il est impossible pour le compilateur de trouver les dfinitions de classe. En revanche, si vous importez un package ou une classe, toute tentative de dfinition dun nom qui provoque un conflit avec un nom import gnre une erreur. Lors de la cration dun package, le spcificateur daccs par dfaut pour tous les membres de ce package est internal, ce qui signifie que, par dfaut, les membres du package ne sont visibles que pour dautres membres de ce package. Si vous souhaitez quune classe soit disponible pour un code externe au package, vous devez la dclarer public. Par exemple, le package suivant contient deux classes, SampleCode et CodeFormatter :
// SampleCode.as file package samples { public class SampleCode {} } // CodeFormatter.as file package samples { class CodeFormatter {} }
La classe SampleCode est visible en dehors du package car elle est dclare comme classe public. La classe CodeFormatter, cependant, est visible uniquement dans le package samples. Toute tentative daccs la classe CodeFormatter en dehors du package samples donne lieu une erreur, comme lindique lexemple suivant :
import samples.SampleCode; import samples.CodeFormatter; var mySample:SampleCode = new SampleCode(); // okay, public class var myFormatter:CodeFormatter = new CodeFormatter(); // error

40
Si vous souhaitez que les deux classes soient disponibles en dehors du package, vous devez les dclarer public. Vous ne pouvez pas appliquer lattribut public la dclaration de package. Les noms entirement qualifis sont utiles pour rsoudre les conflits de noms pouvant se produire lors de lutilisation de packages. Un tel scnario peut se produire si vous importez deux packages qui dfinissent des classes ayant le mme identifiant. Par exemple, considrons le package suivant, qui possde galement une classe appele SampleCode :
package langref.samples { public class SampleCode {} }
Si vous importez les deux classes, comme suit, vous avez un conflit de noms lorsque vous utilisez la classe SampleCode :
import samples.SampleCode; import langref.samples.SampleCode; var mySample:SampleCode = new SampleCode(); // name conflict
Le compilateur na aucun moyen de savoir quelle classe SampleCode il doit utiliser. Pour rsoudre ce conflit, vous devez utiliser le nom entirement qualifi de chaque classe, comme suit :
var sample1:samples.SampleCode = new samples.SampleCode(); var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();
Remarque : les programmeurs ayant une exprience C++ confondent souvent linstruction import avec linstruction #include. La directive #include est ncessaire dans C++ car les compilateurs C++ traitent un fichier la fois et ne cherchent pas de dfinitions de classe dans dautres fichiers, moins quun fichier den-tte ne soit inclus explicitement. ActionScript 3.0 a une directive include, mais elle nest pas conue pour importer des classes et des packages. Pour importer des classes ou des packages dans ActionScript 3.0, vous devez utiliser linstruction import et placer le fichier source qui contient le package dans le chemin de classe.
Espaces de noms
Les espaces de noms vous permettent de contrler la visibilit des proprits et des mthodes que vous crez. Considrez les spcificateurs de contrle daccs public, private, protected et internal comme des espaces de noms intgrs. Si ces spcificateurs de contrle daccs prdfinis ne rpondent pas vos besoins, vous pouvez crer vos propres espaces de noms. Si vous avez lhabitude dutiliser des espaces de noms XML, cette section ne vous fournira pas de nouvelles informations, bien que la syntaxe et les dtails de limplmentation dActionScript soient lgrement diffrents de ceux dXML. Si vous navez jamais travaill avec des espaces de noms, le concept est simple, mais limplmentation possde une terminologie particulire que vous devrez apprendre. Pour comprendre comment fonctionnent les espaces de noms, il convient de savoir que le nom dune proprit ou dune mthode contient deux parties : un identifiant et un espace de noms. Lidentifiant est ce que vous considrez gnralement comme un nom. Par exemple, les identifiants dans la dfinition de classe suivante sont sampleGreeting et sampleFunction() :
class SampleCode { var sampleGreeting:String; function sampleFunction () { trace(sampleGreeting + " from sampleFunction()"); } }

41
Lorsque les dfinitions ne sont pas prcdes dun attribut despace de noms, leurs noms sont qualifis par lespace de noms internal par dfaut, ce qui signifie quils sont visibles uniquement aux appelants du mme package. Si le compilateur est dfini sur le mode strict, il gnre un avertissement indiquant que lespace de noms internal sapplique tout identifiant sans attribut despace de noms. Pour vrifier quun identifiant est disponible partout, vous devez spcifiquement faire prcder le nom de lidentifiant de lattribut public. Dans lexemple de code prcdent, sampleGreeting et sampleFunction() ont une valeur despace de noms dinternal. Vous devez suivre trois tapes de base lorsque vous utilisez des espaces de noms. Premirement, vous devez dfinir lespace de noms laide du mot-cl namespace. Par exemple, le code suivant dfinit lespace de noms version1 :
namespace version1;
Deuximement, vous appliquez votre espace de noms en lutilisant la place dun spcificateur de contrle daccs dans une dclaration de mthode ou de proprit. Lexemple suivant place une fonction appele myFunction() dans lespace de noms version1 :
version1 function myFunction() {}
Troisimement, une fois que vous avez appliqu lespace de noms, vous pouvez le rfrencer laide de la directive use ou en qualifiant le nom dun identifiant avec un espace de nom. Lexemple suivant fait rfrence la fonction myFunction() laide de la directive use :
use namespace version1; myFunction();
Vous pouvez galement utiliser un nom qualifi pour rfrencer la fonction myFunction(), comme lindique lexemple suivant :
version1::myFunction();
Dfinition des espaces de noms Les espaces de noms contiennent une valeur, lURI (Uniform Resource Identifier), parfois appele nom despace de noms. Un URI vous permet de vrifier que votre dfinition despace de noms est unique. Vous crez un espace de noms en dclarant sa dfinition de deux faons diffrentes. Vous pouvez soit dfinir un espace de noms avec un URI explicite, comme vous dfiniriez un espace de noms XML, soit omettre lURI. Lexemple suivant indique comment un espace de noms peut tre dfini laide dun URI :
namespace flash_proxy = "http://www.adobe.com/flash/proxy";
LURI sert de chane didentification unique pour cet espace de noms. Si vous omettez lURI, comme dans lexemple suivant, le compilateur cre une chane didentification interne unique la place. Vous navez pas accs cette chane didentification interne.
namespace flash_proxy;
Une fois que vous avez dfini un espace de noms (avec ou sans URI), vous ne pouvez pas le redfinir dans le mme domaine. Une tentative de dfinition dun espace de noms ayant t dfini dans le mme domaine gnre une erreur du compilateur. Si un espace de noms est dfini dans un package ou une classe, il risque de ne pas tre visible au code externe ce package ou cette classe, moins que vous nutilisiez le spcificateur de contrle daccs appropri. Par exemple, le code suivant indique lespace de noms flash_proxy dfini dans le package flash.utils. Dans lexemple suivant, labsence de spcificateur de contrle daccs signifie que lespace de noms flash_proxy est visible uniquement au code dans le package flash.utils et non au code externe au package :

42
package flash.utils { namespace flash_proxy; }
Le code suivant utilise lattribut public pour rendre lespace de noms flash_proxy visible au code externe au package :
package flash.utils { public namespace flash_proxy; }
Application despaces de noms Appliquer un espace de noms signifie placer une dfinition dans un espace de noms. Les dfinitions que vous pouvez placer dans des espaces de noms peuvent tre des fonctions, des variables et des constantes (vous ne pouvez pas placer une classe dans un espace de noms personnalis). Supposez, par exemple, quune fonction soit dclare laide de lespace de noms de contrle daccs public. Lutilisation de lattribut public dans une dfinition de fonction place la fonction dans lespace de noms public et la rend visible tout le code. Une fois que vous avez dfini un espace de noms, vous pouvez lutiliser de la mme faon que lattribut public, et la dfinition est disponible pour le code pouvant rfrencer votre espace de noms personnalis. Par exemple, si vous dfinissez un espace de noms example1, vous pouvez ajouter une mthode appele myFunction() laide de example1 comme attribut, tel que lindique lexemple suivant :
namespace example1; class someClass { example1 myFunction() {} }
Dclarer la mthode myFunction() laide de lespace de noms example1 comme attribut signifie que la mthode appartient lespace de noms example1. Tenez compte des points suivants lorsque vous appliquez des espaces de noms :
Vous pouvez appliquer un seul espace de noms chaque dclaration. Il nexiste aucun moyen dappliquer un attribut despace de noms plusieurs dfinitions simultanment. En
dautres termes, si vous souhaitez appliquer votre espace de noms dix fonctions diffrentes, vous devez ajouter votre espace de noms comme attribut chacune des dix dfinitions de fonction.
Si vous appliquez un espace de noms, vous ne pouvez pas spcifier un spcificateur de contrle daccs car les
espaces de noms et les spcificateurs de contrle daccs sexcluent mutuellement. En dautres termes, vous ne pouvez pas dclarer une fonction ou une proprit comme public, private, protected ou internal si vous appliquez votre espace de noms. Rfrence despaces de noms Il est inutile de rfrencer explicitement un espace de noms lorsque vous utilisez une mthode ou une proprit dclare avec lun des espaces de noms de contrle daccs (public, private, protected et internal, par exemple). En effet, laccs ces espaces de noms spciaux dpend du contexte. Par exemple, les dfinitions places dans lespace de noms private sont automatiquement disponibles pour le code dans la mme classe. Pour les espaces de noms que vous dfinissez, cependant, le contexte ne compte pas. Pour utiliser une mthode ou une proprit que vous avez place dans un espace de noms personnalis, vous devez rfrencer celui-ci.

43
Vous pouvez rfrencer des espaces de noms avec la directive use namespace ou qualifier le nom avec lespace de noms laide du ponctuateur de qualificatif de nom (::). Le fait de rfrencer un espace de noms avec la directive use namespace ouvre lespace de noms, ce qui permet de lappliquer nimporte quel identifiant non qualifi. Par exemple, si vous avez dfini lespace de noms example1, vous pouvez accder aux noms dans cet espace de noms en utilisant use namespace example1 :
use namespace example1; myFunction();
Vous pouvez ouvrir plusieurs espaces de noms simultanment. Une fois que vous avez ouvert un espace de noms avec use namespace, il reste ouvert dans le bloc de code dans lequel il a t ouvert. Il nexiste aucun moyen pour fermer explicitement un espace de noms. Nanmoins, le fait davoir plusieurs espaces de noms ouverts augmente la probabilit que des conflits de noms se produisent. Si vous prfrez ne pas ouvrir despace de noms, vous pouvez viter la directive use namespace en qualifiant le nom de la proprit ou de la mthode avec lespace de noms et le ponctuateur de qualificatif de nom. Par exemple, le code suivant indique comment vous pouvez qualifier le nom myFunction() avec lespace de noms example1 :
example1::myFunction();
Utilisation despaces de noms Vous pouvez trouver un exemple despace de noms, tir du monde rel, utilis pour viter des conflits sur les noms dans la classe flash.utils.Proxy qui fait partie dActionScript 3.0. La classe Proxy, qui remplace la proprit Object.__resolve dActionScript 2.0, vous permet dintercepter les rfrences aux proprits ou aux mthodes non dfinies avant quune erreur ne se produise. Toutes les mthodes de la classe Proxy se trouvent dans lespace de noms flash_proxy afin dempcher les conflits de noms. Pour mieux comprendre comment lespace de noms flash_proxy est utilis, vous devez savoir comment utiliser la classe Proxy. La fonctionnalit de la classe Proxy est disponible uniquement aux classes qui hritent delle. En dautres termes, si vous souhaitez utiliser les mthodes de la classe Proxy dun objet, la dfinition de classe de lobjet doit tendre la classe Proxy. Par exemple, si vous souhaitez intercepter des tentatives dappel dune mthode non dfinie, vous devez tendre la classe Proxy puis remplacer la mthode callProperty() de la classe Proxy. Limplmentation des espaces de noms est gnralement un processus en trois tapes (dfinition, application et rfrence dun espace de noms). Etant donn que vous nappelez jamais explicitement une mthode de la classe Proxy, cependant, lespace de noms flash_proxy est dfini et appliqu uniquement, jamais rfrenc. ActionScript 3.0 dfinit lespace de noms flash_proxy et lapplique dans la classe Proxy. Votre code doit uniquement appliquer lespace de noms flash_proxy des classes qui tendent la classe Proxy. Lespace de noms flash_proxy est dfini dans le package flash.utils comme illustr ci-dessous :
package flash.utils { public namespace flash_proxy; }
Lespace de noms est appliqu aux mthodes de la classe Proxy comme indiqu dans lextrait suivant issu de la classe Proxy :
public class Proxy { flash_proxy function callProperty(name:*, ... rest):* flash_proxy function deleteProperty(name:*):Boolean ... }

44
Comme lindique le code suivant, vous devez dabord importer la classe Proxy et lespace de noms flash_proxy. Vous devez ensuite dclarer votre classe de faon ce quelle tende la classe Proxy (vous devez galement ajouter lattribut dynamic si vous compilez en mode strict). Lorsque vous remplacez la mthode callProperty(), vous devez utiliser lespace de noms flash_proxy.
package { import flash.utils.Proxy; import flash.utils.flash_proxy; dynamic class MyProxy extends Proxy { flash_proxy override function callProperty(name:*, ...rest):* { trace("method call intercepted: " + name); } } }
Si vous crez une occurrence de la classe MyProxy et appelez une mthode non dfinie (la mthode testing() appele dans lexemple suivant, par exemple), votre objet Proxy intercepte lappel de mthode et excute les instructions se trouvant dans la mthode callProperty() remplace (dans ce cas, une instruction trace() simple).
var mySample:MyProxy = new MyProxy(); mySample.testing(); // method call intercepted: testing
Le fait que les mthodes de la classe Proxy se trouvent dans lespace de noms flash_proxy prsente deux avantages. Premirement, le fait davoir un espace de noms spar rduit lencombrement dans linterface publique des classes qui tendent la classe Proxy (iI existe environ douze mthodes dans la classe Proxy que vous pouvez remplacer. Elles ne sont pas conues pour tre appeles directement. Le fait de toutes les placer dans lespace de noms public peut prter confusion). Deuximement, le fait dutiliser lespace de noms flash_proxy vite les conflits de nom si votre sousclasse Proxy contient des mthodes doccurrence avec des noms correspondant lune des mthodes de la classe Proxy. Par exemple, vous pouvez nommer lune de vos mthodes callProperty(). Le code suivant est acceptable car votre version de la mthode callProperty() se trouve dans un espace de noms diffrent :
dynamic class MyProxy extends Proxy { public function callProperty() {} flash_proxy override function callProperty(name:*, ...rest):* { trace("method call intercepted: " + name); } }
Vous pouvez galement utiliser des espaces de noms pour accder des mthodes ou des proprits autrement quavec les quatre spcificateurs de contrle daccs (public, private, internal et protected). Par exemple, vous pouvez avoir des mthodes dutilitaire parpilles sur plusieurs packages. Vous souhaitez que ces mthodes soient disponibles pour tous vos packages, mais vous ne souhaitez pas quelles soient publiques. Pour cela, vous pouvez crer un espace de noms et lutiliser comme spcificateur de contrle daccs spcial. Lexemple suivant utilise un espace de noms dfini par lutilisateur pour regrouper deux fonctions se trouvant dans diffrents packages. En les regroupant dans le mme espace de noms, vous pouvez rendre les deux fonctions visibles une classe ou un package au moyen dune seule instruction use namespace.

45
Cet exemple utilise quatre fichiers pour dmontrer la technique. Tous les fichiers doivent se trouver dans votre chemin de classe. Le premier fichier, myInternal.as, sert dfinir lespace de noms myInternal. Etant donn que le fichier se trouve dans un package appel example, vous devez placer le fichier dans un dossier appel example. Lespace de noms est marqu comme public pour pouvoir tre import dans dautres packages.
// myInternal.as in folder example package example { public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples"; }
Le deuxime et le troisime fichiers, Utility.as et Helper.as, dfinissent les classes qui contiennent des mthodes devant tre disponibles pour dautres packages. La classe Utility se trouve dans le package example.alpha, ce qui signifie que le fichier doit tre plac dans un dossier appel alpha qui est un sous-dossier du dossier example. La classe Helper se trouve dans le package example.beta, ce qui signifie que le fichier doit tre plac dans un dossier appel beta qui est galement un sous-dossier du dossier example. Ces deux packages, example.alpha et example.beta, doivent importer lespace de noms avant de lutiliser.
// Utility.as in the example/alpha folder package example.alpha { import example.myInternal; public class Utility { private static var _taskCounter:int = 0; public static function someTask() { _taskCounter++; } myInternal static function get taskCounter():int { return _taskCounter; } } }

46
// Helper.as in the example/beta folder package example.beta { import example.myInternal; public class Helper { private static var _timeStamp:Date; public static function someTask() { _timeStamp = new Date(); } myInternal static function get lastCalled():Date { return _timeStamp; } } }
Le quatrime fichier, NamespaceUseCase.as, est la classe de lapplication principale et doit tre un frre pour le dossier example. Dans Flash Professional, cette classe ferait office de classe de document du fichier FLA. La classe NamespaceUseCase importe galement lespace de noms myInternal et lutilise pour appeler les deux mthodes statiques qui rsident dans les autres packages. Lexemple utilise des mthodes statiques pour simplifier le code uniquement. Les mthodes statiques et doccurrence peuvent tre places dans lespace de noms myInternal.
// NamespaceUseCase.as package { import flash.display.MovieClip; import example.myInternal; // import namespace import example.alpha.Utility;// import Utility class import example.beta.Helper;// import Helper class public class NamespaceUseCase extends MovieClip { public function NamespaceUseCase() { use namespace myInternal; Utility.someTask(); Utility.someTask(); trace(Utility.taskCounter); // 2 Helper.someTask(); trace(Helper.lastCalled); // [time someTask() was last called] } } }

47
Variables
Les variables vous permettent de stocker des valeurs que vous utilisez dans votre programme. Pour dclarer une variable, vous devez utiliser linstruction var avec le nom de variable. Dans ActionScript 3.0, lutilisation de linstruction var est obligatoire. Par exemple, la ligne dActionScript suivante dclare une variable appele i :
var i;
Si vous omettez linstruction var lors de la dclaration dune variable, vous obtenez une erreur de compilateur en mode strict et une erreur dexcution en mode standard. Par exemple, la ligne de code suivante provoque une erreur si la variable i na pas t dfinie prcdemment :
i; // error if i was not previously defined
Vous devez associer une variable un type de donnes lorsque vous dclarez la variable. La dclaration dune variable sans dsigner son type est autorise mais provoque un avertissement du compilateur en mode strict. Vous dsignez le type dune variable en ajoutant le nom de variable avec deux-points (:), suivi par le type de variable. Par exemple, le code suivant dclare une variable i de type int :
var i:int;
Vous pouvez affecter une valeur une variable laide de loprateur daffectation (=). Par exemple, le code suivant dclare une variable i et lui affecte la valeur 20 :
var i:int; i = 20;
Il peut tre plus pratique daffecter une valeur une variable au moment o vous dclarez cette dernire, comme dans lexemple suivant :
var i:int = 20;
La technique daffectation dune valeur une variable au moment de sa dclaration est couramment utilise non seulement lors de laffectation de valeurs primitives (nombres entiers et chanes) mais galement lors de la cration dun tableau ou de linstanciation de loccurrence dune classe. Lexemple suivant illustre un tableau dclar auquel est affecte une valeur laide dune ligne de code.
var numArray:Array = ["zero", "one", "two"];
Vous pouvez crer une occurrence dune classe laide de loprateur new. Lexemple suivant cre une occurrence dune classe appele CustomClass et affecte une rfrence loccurrence de classe nouvellement cre sur la variable appele customItem :
var customItem:CustomClass = new CustomClass();
Si vous avez plusieurs variables dclarer, vous pouvez le faire sur une ligne de code laide de loprateur virgule (,) pour sparer les variables. Par exemple, le code suivant dclare trois variables sur une ligne de code :
var a:int, b:int, c:int;
Vous pouvez galement affecter des valeurs chacune des variables sur une mme ligne de code. Par exemple, le code suivant dclare trois variables (a, b, et c) et affecte une valeur chacune dentre elles :
var a:int = 10, b:int = 20, c:int = 30;
Bien que vous puissiez utiliser loprateur virgule pour regrouper des dclarations de variable dans une instruction, ceci risque de rendre votre code moins lisible.

48
Prsentation du domaine dune variable

Le domaine dune variable est la partie de votre code dans laquelle une rfrence lexicale peut accder la variable. Une variable globale est une variable dfinie dans toutes les parties de votre code, alors quune variable locale est une variable dfinie dans une seule partie de votre code. Dans ActionScript 3.0, le domaine des variables est toujours limit la fonction ou la classe dans laquelle elles sont dclares. Une variable globale est une variable que vous dfinissez en dehors de toute dfinition de classe ou de fonction. Par exemple, le code suivant cre une variable globale strGlobal en la dclarant en dehors de toute fonction. Lexemple indique quune variable globale est disponible la fois lintrieur et lextrieur de la dfinition de fonction.
var strGlobal:String = "Global"; function scopeTest() { trace(strGlobal); // Global } scopeTest(); trace(strGlobal); // Global
Vous dclarez une variable locale en dclarant la variable lintrieur dune dfinition de fonction. La plus petite partie de code pour laquelle vous pouvez dfinir une variable locale est une dfinition de fonction. Une variable locale dclare dans une fonction existe uniquement dans celle-ci. Par exemple, si vous dclarez une variable appele str2 dans la fonction localScope(), cette variable nest pas disponible en dehors de la fonction.
function localScope() { var strLocal:String = "local"; } localScope(); trace(strLocal); // error because strLocal is not defined globally
Si le nom attribu votre variable locale est dj dclar en tant que variable globale, la dfinition locale masque la dfinition globale tant que la variable locale est dans le domaine. La variable globale persiste en dehors de la fonction. Par exemple, le code suivant cre une variable globale de type chane appele str1, puis une variable locale du mme nom dans la fonction scopeTest(). Linstruction trace place dans la fonction gnre la valeur locale de la variable, tandis que celle qui est place en dehors de la fonction gnre la valeur globale de la variable.
var str1:String = "Global"; function scopeTest () { var str1:String = "Local"; trace(str1); // Local } scopeTest(); trace(str1); // Global
Les variables ActionScript, contrairement aux variables dans C++ et Java, nont pas de domaine de niveau bloc. Un bloc de code est un groupe dinstructions plac entre une accolade douverture ( { ) et une accolade de fermeture (}). Dans certains langages de programmation tels que C++ et Java, les variables dclares dans un bloc de code ne sont pas disponibles en dehors de ce bloc de code. Cette restriction de domaine est appele domaine de niveau bloc et nexiste pas dans ActionScript. Si vous dclarez une variable lintrieur dun bloc de code, elle est disponible non seulement dans celui-ci mais galement dans dautres parties de la fonction laquelle il appartient. Par exemple, la fonction suivante contient des variables dfinies dans diffrents domaines de bloc. Toutes les variables sont disponibles dans la fonction.

49
function blockTest (testArray:Array) { var numElements:int = testArray.length; if (numElements > 0) { var elemStr:String = "Element #"; for (var i:int = 0; i < numElements; i++) { var valueStr:String = i + ": " + testArray[i]; trace(elemStr + valueStr); } trace(elemStr, valueStr, i); // all still defined } trace(elemStr, valueStr, i); // all defined if numElements > 0 } blockTest(["Earth", "Moon", "Sun"]);
Une implication intressante de labsence de domaine de niveau bloc est que vous pouvez lire ou crire dans une variable avant de la dclarer, tant quelle est dclare avant que la fonction se termine. Ceci est d une technique appele hissage, qui signifie que le compilateur dplace toutes les dclarations de variable en haut de la fonction. Par exemple, le code suivant compile mme si la fonction trace() initiale pour la variable num se produit avant la dclaration de la variable num :
trace(num); // NaN var num:Number = 10; trace(num); // 10
Nanmoins, le compilateur ne hisse aucune instruction daffectation. Ceci explique pourquoi la fonction trace() initiale de num fournit NaN (pas un nombre), qui est la valeur par dfaut pour des variables du type de donnes Number. Cela signifie que vous pouvez affecter des valeurs des variables mme avant leur dclaration, comme indiqu dans lexemple suivant :
num = 5; trace(num); // 5 var num:Number = 10; trace(num); // 10
Valeurs par dfaut

Une valeur par dfaut est le contenu dune variable avant que vous dfinissiez sa valeur. Vous initialisez une variable lorsque vous lui affectez sa premire valeur. Si vous dclarez une variable sans dfinir sa valeur, cette variable est non initialise. La valeur dune variable non initialise dpend de son type de donnes. Le tableau suivant dcrit les valeurs par dfaut des variables, organises par type de donnes :
Type de donnes Boolean int Number Object String Valeur par dfaut
false
0
NaN null null

50
Type de donnes uint Non dclar (quivalent lannotation de type *) Toutes les autres classes, y compris celles dfinies par lutilisateur
Valeur par dfaut 0

undefined null
Pour les variables de type Number, la valeur par dfaut est NaN (pas un nombre), qui est une valeur spciale dfinie par la norme IEEE-754 pour indiquer une valeur qui ne reprsente pas un nombre. Si vous dclarez une variable mais pas son type de donnes, le type de donnes par dfaut * lui est attribu, ce qui signifie quelle nest pas type. Si vous ninitialisez pas non plus de variable non type avec une valeur, sa valeur par dfaut est undefined. Pour les types de donnes autres que Boolean, Number, int, et uint, la valeur par dfaut dune variable non initialise est null. Ceci sapplique toutes les classes dfinies par ActionScript 3.0, ainsi quaux classes personnalises que vous crez. La valeur null nest pas une valeur valide pour des variables de type Boolean, Number, int ou uint. Si vous tentez daffecter la valeur null une telle variable, la valeur est convertie en la valeur par dfaut pour ce type de donnes. Pour les variables de type Object, vous pouvez affecter une valeur null. Si vous tentez daffecter la valeur undefined une variable de type Object, la valeur est convertie en null. Pour les variables de type Number, il existe une fonction de niveau suprieur spciale appele isNaN() qui renvoie la valeur Boolean true si la variable nest pas un nombre, et false autrement.
Types de donnes
Un type de donnes dfinit un ensemble de valeurs. Par exemple, le type de donnes Boolean est lensemble de deux valeurs exactement : true et false. Outre le type de donnes Boolean, ActionScript 3.0 dfinit plusieurs autres types de donnes couramment utiliss tels que String, Number et Array. Vous pouvez dfinir vos types de donns en utilisant des classes ou des interfaces afin de dfinir un ensemble de valeurs personnalis. Toutes les valeurs dans ActionScript 3.0, quelles soient primitives ou complexes, sont des objets. Une valeur primitive est une valeur appartenant lun des types de donnes suivants : Boolean, int, Number, String et uint. Lutilisation de valeurs primitives est gnralement plus rapide que lutilisation de valeurs complexes car ActionScript stocke les valeurs primitives de faon permettre des optimisations de vitesse et de mmoire. Remarque : pour les lecteurs intresss par les dtails techniques, ActionScript stocke les valeurs primitives en tant quobjets inaltrables. Le fait quelles soient stockes en tant quobjets inaltrables signifie que le transfert par rfrence est identique au transfert par valeur. Ceci rduit lutilisation de la mmoire et augmente la vitesse dexcution car les rfrences sont gnralement beaucoup plus petites que les valeurs elles-mmes. Une valeur complexe est une valeur qui nest pas une valeur primitive. Les types de donnes qui dfinissent des ensembles de valeurs complexes comprennent Array, Date, Error, Function, RegExp, XML et XMLList. De nombreux langages de programmation font la distinction entre les valeurs primitives et leurs enveloppes. Java, par exemple, a une valeur primitive int et la classe java.lang.Integer qui lenveloppe. Les valeurs primitives de Java ne sont pas des objets, mais leurs enveloppes le sont, ce qui rend les valeurs primitives utiles pour certaines oprations et les enveloppes pour dautres. Dans ActionScript 3.0, les valeurs primitives et leurs enveloppes ne peuvent tre distingues, des fins pratiques. Toutes les valeurs, mme les valeurs primitives, sont des objets. Le moteur dexcution traite ces types primitifs comme des cas spciaux qui se comportent comme des objets nexigeant pas le temps normal associ la cration dobjets. Cela signifie que les deux lignes de code suivantes sont quivalentes :

51
var someInt:int = 3; var someInt:int = new int(3);
Tous les types de donnes primitifs et complexes rpertoris ci-dessus sont dfinis par les classes de base dActionScript 3.0. Les classes de base vous permettent de crer des objets laide de valeurs littrales au lieu dutiliser loprateur new. Par exemple, vous pouvez crer un tableau laide dune valeur littrale ou du constructeur de classe Array, comme suit :
var someArray:Array = [1, 2, 3]; // literal value var someArray:Array = new Array(1,2,3); // Array constructor
Vrification des types

La vrification des types peut tre effectue lors de la compilation ou de lexcution. Les langages typs statiquement (C++ et Java, par exemple) effectuent la vrification des types lors de la compilation. Les langages typs dynamiquement (Smalltalk et Python, par exemple) effectuent la vrification des types lors de lexcution. En tant que langage typ dynamiquement, ActionScript 3.0 effectue la vrification des types lors de lexcution mais galement lors de la compilation, avec un mode de compilateur spcial appel mode strict. En mode strict, la vrification des types a lieu la fois lors de la compilation et de lexcution, mais en mode standard, elle a lieu lors de lexcution. Les langages typs dynamiquement vous permettent de structurer votre code avec une grande souplesse, mais des erreurs de type risquent de se produire lors de lexcution. Les langages typs statiquement signalent des erreurs de type lors de la compilation mais des informations de type sont requises ce moment-l.
Vrification des types lors de la compilation

La vrification des types lors de la compilation est souvent favorise dans les projets plus importants car au fur et mesure que la taille du projet augmente, la flexibilit du type de donnes devient gnralement moins importante que la capture derreurs de type aussitt que possible. Cest pourquoi le compilateur dActionScript dans Flash Professional et dans Flash Builder est excut en mode strict, par dfaut. Adobe Flash Builder Vous pouvez dsactiver le mode strict dans Flash Builder par le biais des paramtres du compilateur dActionScript dans la bote de dialogue Project Properties.
Pour que la vrification des types soit excute lors de la compilation, le compilateur doit connatre les informations de type de donnes des variables ou expressions que contient votre code. Pour dclarer explicitement un type de donnes pour une variable, ajoutez loprateur deux points (:) suivi du type de donnes comme suffixe du nom de variable. Pour associer un type de donnes un paramtre, utilisez loprateur deux points suivi du type de donnes. Par exemple, le code suivant ajoute des informations de type de donnes au paramtre xParam, et dclare une variable myParam avec un type de donnes explicite :
function runtimeTest(xParam:String) { trace(xParam); } var myParam:String = "hello"; runtimeTest(myParam);
En mode strict, le compilateur dActionScript signale des incompatibilits de type comme erreurs de compilateur. Par exemple, le code suivant dclare un paramtre de fonction xParam, de type Object, mais tente ensuite daffecter des valeurs de type String et Number ce paramtre. Ceci produit une erreur de compilateur en mode strict.

52
function dynamicTest(xParam:Object) { if (xParam is String) { var myStr:String = xParam; // compiler error in strict mode trace("String: " + myStr); } else if (xParam is Number) { var myNum:Number = xParam; // compiler error in strict mode trace("Number: " + myNum); } }
Mme en mode strict, cependant, vous pouvez choisir dabandonner la vrification des types lors de la compilation en laissant la partie droite dune instruction daffectation non type. Vous pouvez marquer une variable ou une expression comme non type soit en omettant une annotation de type, soit laide de lannotation de type astrisque (*) spciale. Par exemple, si le paramtre xParam de lexemple prcdent est modifi de faon ne plus avoir dannotation de type, la compilation seffectue en mode strict :
function dynamicTest(xParam) { if (xParam is String) { var myStr:String = xParam; trace("String: " + myStr); } else if (xParam is Number) { var myNum:Number = xParam; trace("Number: " + myNum); } } dynamicTest(100) dynamicTest("one hundred");
Vrification des types lors de lexcution

La vrification des types lors de lexcution sapplique dans ActionScript 3.0 quel que soit le mode, strict ou standard. Imaginez que la valeur 3 est transmise en tant quargument une fonction qui attend un tableau. En mode strict, le compilateur gnre une erreur car la valeur 3 nest pas compatible avec le type de donnes Array. Si vous dsactivez le mode strict et utilisez le mode standard, le compilateur ne signale pas lincompatibilit de type, mais la vrification des types lors de lexcution provoque une erreur dexcution. Lexemple suivant prsente une fonction appele typeTest() qui attend une instruction Array mais qui reoit une valeur de 3. Ceci provoque une erreur dexcution en mode standard car la valeur 3 nest pas un membre du type de donnes dclar (Array) du paramtre.
function typeTest(xParam:Array) { trace(xParam); } var myNum:Number = 3; typeTest(myNum); // run-time error in ActionScript 3.0 standard mode

53
Il se peut galement que vous obteniez une erreur de type lors de lexcution alors que vous tes en mode strict. Ceci est possible si vous utilisez le mode strict mais que vous abandonnez la vrification des types lors de la compilation laide dune variable non type. Lorsque vous utilisez une variable non type, vous nliminez pas la vrification des types mais la remettez plus tard, au moment de lexcution. Par exemple, si le type de donnes de la variable myNum de lexemple prcdent nest pas dclar, le compilateur ne peut pas dtecter lincompatibilit de type, mais le code gnre une erreur dexcution car il compare la valeur dexcution de myNum (dfinie sur 3 en raison de linstruction daffectation) avec le type de xParam (dfini sur Array).
function typeTest(xParam:Array) { trace(xParam); } var myNum = 3; typeTest(myNum); // run-time error in ActionScript 3.0
La vrification des types lors de lexcution permet galement dutiliser lhritage avec davantage de souplesse que la vrification lors de la compilation. En remettant la vrification des types au moment de lexcution, le mode standard vous permet de rfrencer des proprits dune sous-classe mme si vous effectuez un upcast. Un upcast a lieu lorsque vous utilisez une classe de base pour dclarer le type dune occurrence de classe mais une sous-classe pour linstancier. Par exemple, vous pouvez crer une classe appele ClassBase qui peut tre tendue (les classes avec lattribut final ne peuvent pas tre tendues) :
class ClassBase { }
Vous pouvez ensuite crer une sous-classe de ClassBase appele ClassExtender, qui possde une proprit appele someString, comme suit :
class ClassExtender extends ClassBase { var someString:String; }
Vous pouvez utiliser les deux classes pour crer une occurrence de classe dclare laide du type de donnes ClassBase mais instancie avec le constructeur ClassExtender. Un upcast est considr comme une opration sre car la classe de base ne contient aucune proprit ni mthode ne se trouvant pas dans la sous-classe.
var myClass:ClassBase = new ClassExtender();
Une sous-classe, nanmoins, contient des proprits et des mthodes que sa classe de base ne contient pas. Par exemple, la classe ClassExtender contient la proprit someString qui nexiste pas dans la classe ClassBase. Dans ActionScript 3.0 en mode standard, vous pouvez rfrencer cette proprit laide de loccurrence myClass sans gnrer derreur dexcution, comme indiqu dans lexemple suivant :
var myClass:ClassBase = new ClassExtender(); myClass.someString = "hello"; // no error in ActionScript 3.0 standard mode

54
Oprateur is
Loprateur is permet de tester si une variable ou une expression est membre dun type de donnes. Dans les versions prcdentes dActionScript, loprateur instanceof offrait cette fonctionnalit, mais dans ActionScript 3.0, loprateur instanceof ne doit pas tre utilis pour tester lappartenance un type de donnes. Loprateur is doit tre utilis la place de loprateur instanceof pour la vrification des types manuelle car lexpression x instanceof y vrifie simplement la chane de prototype de x pour voir si y existe (et dans ActionScript 3.0, la chane de prototype ne donne pas une image complte de la hirarchie dhritage). Loprateur is examine sa hirarchie dhritage et peut tre utilis pour vrifier non seulement si un objet est une occurrence dune classe particulire mais galement si un objet est une occurrence dune classe qui implmente une interface particulire. Lexemple suivant cre une occurrence de la classe Sprite appele mySprite et utilise loprateur is pour tester si mySprite est une occurrence des classes Sprite et DisplayObject, et si elle implmente linterface IEventDispatcher :
var mySprite:Sprite = new Sprite(); trace(mySprite is Sprite); // true trace(mySprite is DisplayObject);// true trace(mySprite is IEventDispatcher); // true
Loprateur is vrifie la hirarchie dhritage et signale correctement que mySprite est compatible avec les classes Sprite et DisplayObject (la classe Sprite est une sous-classe de la classe DisplayObject). Loprateur is vrifie galement si mySprite hrite dune classe qui implmente linterface IEventDispatcher. Etant donn que la classe Sprite hrite de la classe EventDispatcher, qui implmente linterface IEventDispatcher, loprateur is signale correctement que mySprite implmente la mme interface. Lexemple suivant prsente les mmes tests que lexemple prcdent, mais avec instanceof au lieu de loprateur is. Loprateur instanceof identifie correctement que mySprite est une occurrence de Sprite ou de DisplayObject, mais il renvoie false lorsquil est utilis pour tester si mySprite implmente linterface IEventDispatcher.
trace(mySprite instanceof Sprite); // true trace(mySprite instanceof DisplayObject);// true trace(mySprite instanceof IEventDispatcher); // false
Oprateur as
Loprateur as permet galement de vrifier si une expression est membre dun type de donnes. Contrairement loprateur is, cependant, loprateur as ne renvoie pas de valeur boolenne. Loprateur as renvoie la valeur de lexpression au lieu de true, et null au lieu de false. Lexemple suivant indique les rsultats obtenus si vous utilisez loprateur as au lieu de loprateur is pour vrifier simplement si une occurrence de Sprite appartient aux types de donnes DisplayObject, IEventDispatcher et Number.
var mySprite:Sprite = new Sprite(); trace(mySprite as Sprite); // [object Sprite] trace(mySprite as DisplayObject); // [object Sprite] trace(mySprite as IEventDispatcher); // [object Sprite] trace(mySprite as Number); // null
Lorsque vous utilisez loprateur as, loprande droite doit tre un type de donnes. Vous obtenez une erreur si vous tentez dutiliser une expression autre quun type de donnes comme oprande droite.
Classes dynamiques
Une classe dynamique dfinit un objet qui peut tre modifi lors de lexcution en ajoutant ou en modifiant des proprits et des mthodes. Une classe qui nest pas dynamique (la classe String, par exemple), est une classe scelle. Vous ne pouvez pas ajouter de proprits ni de mthodes une classe scelle lors de lexcution.

55
Vous crez des classes dynamiques en utilisant lattribut dynamic lorsque vous dclarez une classe. Par exemple, le code suivant cre une classe dynamique appele Protean :
dynamic class Protean { private var privateGreeting:String = "hi"; public var publicGreeting:String = "hello"; function Protean() { trace("Protean instance created"); } }
Si vous instanciez ensuite une occurrence de la classe Protean, vous pouvez lui ajouter des proprits ou des mthodes en dehors de la dfinition de classe. Par exemple, le code suivant cre une occurrence de la classe Protean et lui ajoute une proprit appele aString et une autre appele aNumber :
var myProtean:Protean = new Protean(); myProtean.aString = "testing"; myProtean.aNumber = 3; trace(myProtean.aString, myProtean.aNumber); // testing 3
Les proprits que vous ajoutez une occurrence dune classe dynamique sont des entits dexcution. Par consquent, toute vrification des types est effectue lors de lexcution. Vous ne pouvez pas ajouter une annotation de type une proprit que vous ajoutez de cette faon. Vous pouvez galement ajouter une mthode loccurrence myProtean en dfinissant une fonction et en lassociant une proprit de loccurrence myProtean. Le code suivant dplace linstruction trace dans une mthode appele traceProtean() :
var myProtean:Protean = new Protean(); myProtean.aString = "testing"; myProtean.aNumber = 3; myProtean.traceProtean = function () { trace(this.aString, this.aNumber); }; myProtean.traceProtean(); // testing 3
Cependant, les mthodes cres de cette manire nont pas accs des mthodes ou des proprits prives de la classe Protean. De plus, mme les rfrences des mthodes ou des proprits publiques de la classe Protean doivent tre qualifies avec le mot-cl this ou le nom de classe. Lexemple suivant prsente la mthode traceProtean() tentant daccder aux variables prives et publiques de la classe Protean.
myProtean.traceProtean = function () { trace(myProtean.privateGreeting); // undefined trace(myProtean.publicGreeting); // hello }; myProtean.traceProtean();
Descriptions des types de donnes

Les types de donnes primitifs peuvent tre Boolean, int, Null, Number, String, uint et void. Les classes de base dActionScript dfinissent galement les types de donnes complexes suivants : Object, Array, Date, Error, Function, RegExp, XML et XMLList.

56
Type de donnes Boolean

Le type de donnes Boolean comporte deux valeurs : true et false. Les variables du type boolen ne prennent en charge aucune autre valeur. La valeur par dfaut dune variable boolenne qui a t dclare mais non initialise est false.
Type de donnes int

Le type de donnes int est stock en interne en tant que nombre entier 32 bits et comprend lensemble des entiers allant de -2 147 483 648 (-231) 2 147 483 647 (231 - 1), inclus. Les versions prcdentes dActionScript offraient uniquement le type de donnes Number, qui tait utilis la fois pour les nombres entiers et les nombres en virgule flottante. Dans ActionScript 3.0, vous avez maintenant accs des types machine de bas niveau pour les nombres entiers 32 bits signs et non signs. Si la variable ne doit pas utiliser de nombres en virgule flottante, il est plus rapide et efficace dutiliser le type de donnes int plutt que le type de donnes Number. Pour les valeurs entires en dehors de la plage des valeurs int minimum et maximum, utilisez le type de donnes Number, qui peut grer des valeurs positives et ngatives 9 007 199 254 740 992 (valeurs entires 53 bits). La valeur par dfaut pour des variables du type de donnes int est 0.
Type de donnes Null

Le type de donnes Null contient une seule valeur, null. Il sagit de la valeur par dfaut pour le type de donnes String et toutes les classes qui dfinissent des types de donnes complexes, y compris la classe Object. Aucun des autres types de donnes primitifs (Boolean, Number, int et uint) ne contient la valeur null. A lexcution, la valeur null est convertie en la valeur par dfaut approprie si vous tentez daffecter null des variables de type Boolean, Number, int ou uint. Vous ne pouvez pas utiliser ce type de donns comme annotation de type.
Type de donnes Number

Dans ActionScript 3.0, le type de donnes Number peut reprsenter des entiers, des entiers non signs et des nombres en virgule flottante. Nanmoins, pour optimiser les performances, utilisez le type de donnes Number uniquement pour des valeurs entires suprieures ce que les types int et uint 32 bits peuvent stocker ou pour des nombres en virgule flottante. Pour stocker un nombre en virgule flottante, vous devez y insrer une virgule. Si vous omettez la virgule, le nombre est stock comme nombre entier. Le type de donnes Number utilise le format deux dcimales (64 bits) conformment la norme IEEE 754. Cette norme dicte comment les nombres en virgule flottante sont stocks laide des 64 bits disponibles. Un bit est utilis pour dsigner si le nombre est positif ou ngatif. Onze bits sont utiliss pour lexposant, qui est stock comme base 2. Les 52 bits restants sont utiliss pour stocker le significande (galement appel mantisse), qui correspond au nombre lev la puissance indiqu par lexposant. En utilisant certains de ses bits pour stocker un exposant, le type de donnes Number peut stocker des nombres en virgule flottante beaucoup plus grands que sil utilisait tous ses bits pour le significande. Par exemple, si le type de donnes Number utilisait les 64 bits pour stocker le significande, il pourrait stocker un nombre aussi grand que 265 - 1. En utilisant 11 bits pour stocker un exposant, le type de donnes Number peut lever son significande une puissance de 21023. Les valeurs maximum et minimum que le type Number peut reprsenter sont stockes dans des proprits statiques de la classe Number appeles Number.MAX_VALUE et Number.MIN_VALUE.
Number.MAX_VALUE == 1.79769313486231e+308 Number.MIN_VALUE == 4.940656458412467e-324

57
Bien que cette plage de nombres soit norme, elle est dune grande prcision. Le type de donnes Number utilise 52 bits pour stocker le significande. Par consquent, les nombres ncessitant plus de 52 bits pour une reprsentation prcise (la fraction 1/3, par exemple) ne sont que des approximations. Si votre application exige une prcision absolue avec des nombres dcimaux, vous devez utiliser le logiciel qui implmente larithmtique flottante dcimale plutt que larithmtique flottante binaire. Lorsque vous stockez des valeurs entires avec le type de donnes Number, seuls les 52 bits du significande sont utiliss. Le type de donnes Number utilise ces 52 bits et un bit masqu spcial pour reprsenter des nombres entiers de -9 007 199 254 740 992 (-253) 9 007 199 254 740 992 (253). La valeur NaNest utilise non seulement comme valeur par dfaut pour des variables de type Number, mais galement comme rsultat de toute opration devant renvoyer un nombre mais ne le faisant pas. Par exemple, si vous tentez de calculer la racine carre dun nombre ngatif, le rsultat est NaN. Dautres valeurs Number spciales comprennent linfini positif et linfini ngatif. Remarque : le rsultat de la division par 0 nest NaN que si le diviseur est galement 0. La division par 0 produit infinity lorsque le dividende est positif ou -infinity lorsquil est ngatif.
Type de donnes String

Le type de donnes String reprsente une squence de caractres 16 bits. Les chanes sont stockes en interne sous forme de caractres Unicode, au format UTF-16. Les chanes sont des valeurs inaltrables, comme dans le langage de programmation Java. Toute opration effectue sur une valeur String renvoie une nouvelle occurrence de la chane. La valeur par dfaut dune variable dclare avec le type de donnes String est null. La valeur null nest pas identique la chane vide (""). Elle signifie quaucune valeur nest stocke dans la variable, alors que la chane vide indique que la valeur de la variable est une chane ne contenant pas de caractres.
Type de donnes uint

Le type de donnes uint est stock en interne sous la forme dun entier 32 bits non sign et est constitu de lensemble dentiers compris entre 0 et 4 294 967 295 (232-1), inclus. Utilisez le type de donnes uint dans des situations spciales ncessitant des entiers non ngatifs. Par exemple, vous devez utiliser le type de donnes uint pour reprsenter les valeurs de couleur des pixels car le type de donnes int a un bit de signe interne non appropri pour la gestion des valeurs de couleur. Pour les valeurs dentiers suprieures la valeur uint maximale, utilisez le type de donnes Number qui peut grer des valeurs dentiers 53 bits. La valeur par dfaut pour des variables du type de donnes uint est 0.
Type de donnes Void

Le type de donnes void contient une seule valeur, undefined. Dans les versions prcdentes dActionScript, undefined tait la valeur par dfaut des occurrences de la classe Object. Dans ActionScript 3.0, la valeur par dfaut des occurrences Object est null. Si vous tentez daffecter la valeur undefined une occurrence de la classe Object, la valeur est convertie en null. Vous pouvez affecter uniquement une valeur de undefined des variables non types. Les variables non types sont des variables dpourvues de toute annotation de type, ou qui utilisent lastrisque (*) pour lannotation de type. Vous pouvez utiliser void uniquement comme annotation de type renvoy.
Type de donnes Object

Ce type de donnes est dfini par la classe Object. La classe Object sert de classe de base pour toutes les dfinitions de classe dans ActionScript. La version dActionScript 3.0 du type de donnes Object diffre de celle des versions prcdentes de trois faons. Premirement, le type de donnes Object nest plus le type de donnes par dfaut affect aux variables sans annotation de type. Deuximement, le type de donnes Object ne comprend plus la valeur undefined, qui tait la valeur par dfaut des occurrences Object. Troisimement, dans ActionScript 3.0, la valeur par dfaut des occurrences de la classe Object est null.

58
Dans les versions prcdentes dActionScript, une variable sans annotation de type tait affecte automatiquement au type de donnes Object. Ceci nest plus valable dans ActionScript 3.0, qui inclut maintenant la notion de variable parfaitement non type. Les variables sans annotation de type sont dsormais considres comme non types. Si vous souhaitez faire comprendre aux lecteurs de votre code que vous souhaitez laisser une variable non type, vous pouvez utiliser lastrisque (*) pour lannotation de type, ce qui revient omettre celle-ci. Lexemple suivant prsente deux instructions quivalentes qui dclarent une variable non type x :
var x var x:*
Seules les variables non types peuvent contenir la valeur undefined. Si vous tentez daffecter la valeur undefined une variable ayant un type de donnes, le moteur dexcution convertit la valeur undefined en la valeur par dfaut pour ce type de donnes. Pour des occurrences du type de donnes Object, la valeur par dfaut est null ; autrement dit, si vous tentez daffecter la valeur undefined une occurrence dObject, la valeur est convertie en null.
Conversions de type
Une conversion de type a lieu lorsquune valeur est transforme en une valeur dun type de donnes diffrent. Les conversions de type peuvent tre implicites ou explicites. Les conversions implicites (ou coercition) sont parfois effectues lors de lexcution. Par exemple, si la valeur 2 est affecte une variable du type de donnes Boolean, elle est convertie en la valeur boolenne true avant son affectation. Les conversions explicites (ou association) ont lieu lorsque votre code demande au compilateur de traiter une variable dun type de donnes comme si elle appartenait un type de donnes diffrent. Lorsque des valeurs primitives sont impliques, lassociation convertit les valeurs dun type de donnes en un autre. Pour associer un objet un autre type de donnes, vous mettez le nom de lobjet entre parenthses et le faites prcder du nom du nouveau type. Par exemple, le code suivant prend une valeur boolenne et la transforme en entier numrique :
var myBoolean:Boolean = true; var myINT:int = int(myBoolean); trace(myINT); // 1
Conversions implicites Les conversions implicites ont lieu lors de lexcution dans plusieurs contextes :
Dans des instructions daffectation Lorsque des valeurs sont transmises en tant quarguments de fonction Lorsque des valeurs sont renvoyes partir de fonctions Dans les expressions utilisant certains oprateurs tels que loprateur daddition (+)
Pour les types dfinis par lutilisateur, les conversions implicites ont lieu lorsque la valeur convertir est une occurrence de la classe de destination ou dune classe qui drive de cette dernire. En cas dchec de la conversion implicite, une erreur se produit. Par exemple, le code suivant contient une conversion implicite ayant russi et une conversion implicite ayant chou:
class A {} class B extends A {} var objA:A = new A(); var objB:B = new B(); var arr:Array = new Array(); objA = objB; // Conversion succeeds. objB = arr; // Conversion fails.

59
Pour les types primitifs, les conversions implicites sont gres par appel des algorithmes de conversion internes appels par les fonctions de conversion explicite. Conversions explicites Les conversions explicites, ou association, sont utiles lorsque vous compilez en mode strict et que vous ne souhaitez pas quune incompatibilit de types gnre une erreur de compilation. Ceci peut se produire lorsque vous savez que la coercition convertira vos valeurs correctement lors de lexcution. Par exemple, lorsque vous utilisez des donnes reues dun formulaire, vous pouvez utiliser la coercition pour convertir certaines valeurs de chane en valeurs numriques. Le code suivant gnre une erreur de compilation mme si le code sexcute correctement en mode standard :
var quantityField:String = "3"; var quantity:int = quantityField; // compile time error in strict mode
Si vous souhaitez continuer utiliser le mode strict, mais que vous souhaitez que la chane soit convertie en nombre entier, vous pouvez utiliser la conversion explicite, comme suit :
var quantityField:String = "3"; var quantity:int = int(quantityField); // Explicit conversion succeeds.
Association int, uint et Number Vous pouvez associer tout type de donnes lun des trois types de nombre suivants : int, uint et Number. Si, pour une raison quelconque, la conversion du nombre est impossible, la valeur par dfaut 0 est affecte pour les types de donnes int et uint, et la valeur par dfaut NaN est affecte pour le type de donnes Number. Si vous convertissez une valeur boolenne en un nombre, true devient la valeur 1 et false devient la valeur 0.
var myBoolean:Boolean = true; var myUINT:uint = uint(myBoolean); var myINT:int = int(myBoolean); var myNum:Number = Number(myBoolean); trace(myUINT, myINT, myNum); // 1 1 1 myBoolean = false; myUINT = uint(myBoolean); myINT = int(myBoolean); myNum = Number(myBoolean); trace(myUINT, myINT, myNum); // 0 0 0
Les valeurs de chane qui contiennent des chiffres uniquement peuvent tre converties en lun des types de nombre. Les types de nombre peuvent galement convertir des chanes ressemblant des nombres ngatifs ou des chanes reprsentant une valeur hexadcimale (par exemple, 0x1A). Le processus de conversion ignore les espaces blancs gauche ou droite dans la valeur de chane. Vous pouvez galement associer des chanes qui ressemblent des nombres en virgule flottante laide de Number(). Le fait dinclure une virgule fait que uint() et int() renvoient un entier avec les caractres suivant la virgule ayant t tronqus. Par exemple, les valeurs de chane suivantes peuvent tre associes des nombres :
trace(uint("5")); // 5 trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE trace(uint(" 27 ")); // 27 trace(uint("3.7")); // 3 trace(int("3.7")); // 3 trace(int("0x1A")); // 26 trace(Number("3.7")); // 3.7

60
Les valeurs de chane qui contiennent des caractres non numriques renvoient 0 lors de lassociation int() ou uint() et NaN lors de lassociation Number(). Le processus de conversion ignore les espaces blancs gauche et droite mais renvoie 0 ou NaN si une chane contient un espace blanc sparant deux nombres.
trace(uint("5a")); // 0 trace(uint("ten")); // 0 trace(uint("17 63")); // 0
Dans ActionScript 3.0, la fonction Number() ne prend plus en charge les nombres octaux, ou de base 8. Si vous fournissez une chane avec un zro gauche la fonction Number() dActionScript 2.0, le nombre est interprt comme un nombre octal et converti en son quivalent dcimal. Ceci ne sapplique pas la fonction Number() dans ActionScript 3.0, qui ignore le zro gauche. Par exemple, le code suivant gnre un rsultat diffrent lorsquil est compil laide de diffrentes versions dActionScript :
trace(Number("044")); // ActionScript 3.0 44 // ActionScript 2.0 36
Lassociation nest pas ncessaire lorsquune valeur dun type numrique est affecte une variable dun type numrique diffrent. Mme en mode strict, les types numriques sont convertis de faon implicite en dautres types numriques. Ceci signifie que dans certains cas, des valeurs inattendues peuvent tre renvoyes lorsque la plage dun type est dpasse. Les exemples suivants compilent tous en mode strict, mme si certains gnrent des valeurs inattendues :
var myUInt:uint = -3; // Assign int/Number value to uint variable trace(myUInt); // 4294967293 var myNum:Number = sampleUINT; // Assign int/uint value to Number variable trace(myNum) // 4294967293 var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable trace(myInt); // 0 myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable trace(myInt); // -2147483648
Le tableau suivant rcapitule les rsultats de lassociation au type de donnes Number, int, ou uint partir dautres types de donnes.
Valeur ou type de donnes Boolean Date Rsultat de la conversion en Number, int ou uint
Si la valeur est true, 1 ; sinon, 0. Reprsentation interne de lobjet Date, qui est le nombre de millisecondes depuis le 1er janvier 1970, minuit, heure universelle. 0 Si loccurrence est null et convertie en Number, NaN ; sinon, 0. Un nombre si la chane peut tre convertie en nombre ; sinon, NaN si elle est convertie en Number ou 0 si elle convertie en int ou uint. Si converti en Number, NaN ; si converti en int ou uint, 0.
null
Object String
undefined

61
Association Boolean Lassociation Boolean partir de nimporte quel type de donnes numriques (uint, int et Number) donne false si la valeur numrique est 0, et true autrement. Pour le type de donnes Number, la valeur NaN donne galement false. Lexemple suivant indique les rsultats de lassociation des chiffres -1, 0, et 1 :
var myNum:Number; for (myNum = -1; myNum<2; myNum++) { trace("Boolean(" + myNum +") is " + Boolean(myNum)); }
Le rsultat de lexemple indique que sur les trois chiffres, seul 0 renvoie une valeur false :
Boolean(-1) is true Boolean(0) is false Boolean(1) is true
Lassociation Boolean partir dune valeur String renvoie false si la chane est null ou une chane vide (""). Sinon, elle renvoie true.
var str1:String; // Uninitialized string is null. trace(Boolean(str1)); // false var str2:String = ""; // empty string trace(Boolean(str2)); // false var str3:String = " "; // white space only trace(Boolean(str3)); // true
Lassociation Boolean partir dune occurrence de la classe Object renvoie false si loccurrence est null, et true autrement :
var myObj:Object; // Uninitialized object is null. trace(Boolean(myObj)); // false myObj = new Object(); // instantiate trace(Boolean(myObj)); // true
Les variables boolennes bnficient dun traitement particulier en mode strict car vous pouvez affecter des valeurs de tout type de donnes une variable boolenne sans association. La coercition implicite de tous les types de donnes au type de donnes Boolean a lieu mme en mode strict. En dautres termes, contrairement la plupart de tous les autres types de donnes, lassociation Boolean nest pas ncessaire pour viter des erreurs en mode strict. Les exemples suivants compilent tous en mode strict et se comportent comme prvu lors de lexcution :
var myObj:Object = new Object(); // instantiate var bool:Boolean = myObj; trace(bool); // true bool = "random string"; trace(bool); // true bool = new Array(); trace(bool); // true bool = NaN; trace(bool); // false
Le tableau suivant rcapitule les rsultats de lassociation au type de donnes Boolean partir dautres types de donnes :

62
Valeur ou type de donnes String

null
Rsultat de la conversion en Boolean

false si la valeur est null ou la chane vide ("") ; true autrement. false false si la valeur est NaN ou 0 ; true autrement. false si loccurrence est null ; true autrement.
Number, int ou uint Object
Association String Lassociation au type de donnes String partir de nimporte quel type de donnes numrique renvoie une reprsentation sous forme de chane du nombre. Lassociation au type de donnes String partir dune valeur boolenne renvoie la chane "true" si la valeur est true, et renvoie la chane "false" si la valeur est false. Lassociation au type de donnes String partir dune occurrence de la classe Object renvoie la chane "null" si loccurrence est null. Autrement, lassociation au type String partir de la classe Object renvoie la chane "[object Object]". Lassociation String partir dune occurrence de la classe Array renvoie une chane comprenant une liste spare par des virgules de tous les lments du tableau. Par exemple, lassociation suivante au type de donnes String renvoie une chane contenant les trois lments du tableau :
var myArray:Array = ["primary", "secondary", "tertiary"]; trace(String(myArray)); // primary,secondary,tertiary
Lassociation String partir dune occurrence de la classe Date renvoie une reprsentation sous forme de chane de la date que loccurrence contient. Par exemple, lexemple suivant renvoie une reprsentation sous forme de chane de loccurrence de la classe Date (le rsultat indiqu correspond lheure dt de la cte ouest des Etats-Unis) :
var myDate:Date = new Date(2005,6,1); trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005
Le tableau suivant rcapitule les rsultats de lassociation au type de donnes String partir dautres types de donnes.
Valeur ou type de donnes Array Boolean Date
null
Rsultat de la conversion en chane Une chane compose de tous les lments du tableau "true" ou "false" Une reprsentation sous forme de chane de lobjet Date
"null"
Number, int ou uint Object
Une reprsentation sous forme de chane du nombre Si loccurrence est null, "null" ; sinon, "[object Object]".
Syntaxe
La syntaxe dun langage dfinit un ensemble de rgles suivre lors de lcriture du code excutable.

63
Respect de la casse
ActionScript 3.0 est un langage qui fait la distinction entre les majuscules et les minuscules. Les identifiants qui diffrent au niveau de la casse uniquement sont considrs comme diffrents. Par exemple, le code suivant cre deux variables diffrentes :
var num1:int; var Num1:int;
Syntaxe point
Loprateur point (.) permet daccder aux proprits et aux mthodes dun objet. La syntaxe point vous permet de vous rapporter une mthode ou une proprit de classe laide dun nom doccurrence, suivi par loprateur point et le nom de la mthode ou de la proprit. Par exemple, considrez la dfinition de classe suivante :
class DotExample { public var prop1:String; public function method1():void {} }
La syntaxe point vous permet daccder la proprit prop1 et la mthode method1() laide du nom doccurrence cr dans le code suivant :
var myDotEx:DotExample = new DotExample(); myDotEx.prop1 = "hello"; myDotEx.method1();
Vous pouvez utiliser la syntaxe point lorsque vous dfinissez des packages. Vous utilisez loprateur point pour rfrencer des packages imbriqus. Par exemple, la classe EventDispatcher se trouve dans un package appel events qui est imbriqu dans le package nomm flash. Vous pouvez rfrencer le package events laide de lexpression suivante :
flash.events
Vous pouvez galement rfrencer la classe EventDispatcher au moyen de cette expression :

flash.events.EventDispatcher
Syntaxe barre oblique

La syntaxe barre oblique nest pas prise en charge dans ActionScript 3.0. Elle tait utilise dans les versions antrieures dActionScript pour indiquer le chemin dun clip ou dune variable.
Littraux
Un littral est une valeur qui apparat directement dans votre code. Voici quelques exemples de littraux :
17 "hello" -3 9.4 null undefined true false

64
Les littraux peuvent galement tre regroups pour former des littraux composs. Les littraux de tableau sont placs entre crochets ([]) et utilisent la virgule pour sparer les lments du tableau. Un littral de tableau permet dinitialiser un tableau. Les exemples suivants prsentent deux tableaux initialiss par des littraux de tableau. Vous pouvez utiliser linstruction new et transmettre le littral compos sous forme de paramtre au constructeur de classe Array, ou affecter directement les valeurs littrales lors de linstanciation des occurrences des classes de base ActionScript suivantes : Object, Array, String, Number, int, uint, XML, XMLList et Boolean.
// Use new statement. var myStrings:Array = new Array(["alpha", "beta", "gamma"]); var myNums:Array = new Array([1,2,3,5,8]); // Assign literal directly. var myStrings:Array = ["alpha", "beta", "gamma"]; var myNums:Array = [1,2,3,5,8];
Les littraux permettent galement dinitialiser un objet gnrique. Un objet gnrique est une occurrence de la classe Object. Les littraux dobjet sont placs entre accolades ({}) et sparent les proprits de lobjet par une virgule. Chaque proprit est dclare avec le caractre deux-points (:), sparant le nom et la valeur de la proprit. Vous pouvez crer un objet gnrique via linstruction new et transmettre le littral dobjet sous forme de paramtre au constructeur de classe Object ou affecter directement le littral dobjet loccurrence dclare. Lexemple suivant illustre deux mthodes diffrentes de crer un objet gnrique et de linitialiser avec trois proprits (propA, propB et propC), chacune avec des valeurs dfinies sur 1, 2, et 3, respectivement :
// Use new statement and add properties. var myObject:Object = new Object(); myObject.propA = 1; myObject.propB = 2; myObject.propC = 3; // Assign literal directly. var myObject:Object = {propA:1, propB:2, propC:3};
Voir aussi
Utilisation des chanes Utilisation dexpressions rgulires Initialisation de variables XML
Points-virgules
Vous pouvez utiliser le point-virgule (;) la fin dune instruction. Si vous omettez ce caractre, le compilateur suppose que chaque ligne de code reprsente une instruction distincte. Etant donn que de nombreux programmeurs ont lhabitude dutiliser le point-virgule pour marquer la fin dune instruction, vous pouvez faciliter la lecture de votre code en procdant de la sorte. Lajout dun point-virgule la fin dune instruction permet de placer plusieurs instructions sur une mme ligne, mais rend la lecture de votre code plus difficile.

65
Parenthses
Vous pouvez utiliser les parenthses (()) de trois faons dans ActionScript 3.0. Premirement, elles permettent de modifier lordre des oprations dans une expression. Les oprations regroupes lintrieur de parenthses sont toujours excutes en premier lieu. Par exemple, vous pouvez utiliser des parenthses pour modifier lordre des oprations dans le code suivant :
trace(2 + 3 * 4); // 14 trace((2 + 3) * 4); // 20
Deuximement, vous pouvez utiliser des parenthses avec loprateur virgule (,) pour valuer une srie dexpressions et renvoyer le rsultat de lexpression finale, comme indiqu dans lexemple suivant :
var a:int = 2; var b:int = 3; trace((a++, b++, a+b)); // 7
Troisimement, vous pouvez utiliser des parenthses pour transmettre un ou plusieurs paramtres des fonctions ou des mthodes, comme indiqu dans lexemple suivant, qui transmet une valeur String la fonction trace() :
trace("hello"); // hello
Commentaires
Le code ActionScript 3.0 prend en charge deux types de commentaires : les commentaires dune ligne et les commentaires de plusieurs lignes. Ces mcanismes de commentaire sont semblables aux mcanismes de commentaire de C++ et Java. Le compilateur ne tient pas compte du texte marqu comme commentaire. Les commentaires dune ligne commencent par deux barres obliques (//) et continuent jusqu la fin de la ligne. Par exemple, le code suivant contient un commentaire dune ligne :
var someNumber:Number = 3; // a single line comment
Les commentaires de plusieurs lignes commencent par une barre oblique et un astrisque (/*) et se terminent pas un astrisque et une barre oblique (*/).
/* This is multiline comment that can span more than one line of code. */
Mots-cls et mots rservs

Les mots rservs ne peuvent pas servir didentifiants dans votre code car leur utilisation est rserve ActionScript. Les mots rservs comprennent les mots lexicaux qui sont supprims de lespace de noms du programme par le compilateur. Le compilateur signale une erreur si vous utilisez un mot-cl lexical comme identifiant. Le tableau suivant rpertorie les mots lexicaux dActionScript 3.0.
as class delete false if instanceof native break const do finally implements interface new case continue else for import internal null catch default extends fonction in is package

66
private super to use with
protected switch true var
public this try void
return throw typeof while
Il existe un petit ensemble de mots-cls, appels mots-cls syntaxiques qui peuvent servir didentifiants, mais qui possdent une signification spciale dans certains contextes. Le tableau suivant rpertorie les mots-cls syntaxiques dActionScript 3.0.
each inclure override get dynamique static set final namespace native
Il existe galement plusieurs identifiants auxquels il est parfois fait rfrence sous le terme mots rservs pour une utilisation future. Ces identifiants ne sont pas rservs par ActionScript 3.0, mme si certains risquent dtre considrs comme des mots-cls par le logiciel incorporant ActionScript 3.0. Vous pourrez peut-tre utiliser un grand nombre dentre eux dans votre code, mais Adobe vous le dconseille car il est possible quils soient utiliss en tant que motscls dans une version ultrieure du langage.
abstract char export long throws virtual boolean debugger float prototype to volatile byte double goto short transient cast enum intrinsic synchronized type
Constantes
ActionScript 3.0 prend en charge linstruction const que vous pouvez utiliser pour crer des constantes. Les constantes sont des proprits dont la valeur est fixe et non modifiable. Vous pouvez affecter une valeur une constante une seule fois, et laffectation doit avoir lieu proximit de la dclaration de la constante. Par exemple, si une constante est dclare en tant que membre dune classe, vous pouvez lui affecter une valeur uniquement dans la dclaration ou dans le constructeur de classe. Le code suivant dclare deux constantes. La premire constante, MINIMUM, a une valeur affecte dans linstruction de dclaration. La seconde constante, MAXIMUM, a une valeur affecte dans le constructeur. Observez que cet exemple compile uniquement en mode standard car, en mode strict, il est uniquement possible daffecter une valeur de constante lors de linitialisation.

67
class A { public const MINIMUM:int = 0; public const MAXIMUM:int; public function A() { MAXIMUM = 10; } } var a:A = new A(); trace(a.MINIMUM); // 0 trace(a.MAXIMUM); // 10
Une erreur se produit si vous tentez daffecter une valeur initiale une constante de toute autre faon. Par exemple, si vous tentez de dfinir la valeur initiale de MAXIMUM en dehors de la classe, une erreur dexcution se produit.
class A { public const MINIMUM:int = 0; public const MAXIMUM:int; } var a:A = new A(); a["MAXIMUM"] = 10; // run-time error
ActionScript 3.0 dfinit un large ventail de constantes votre usage. Par convention, les constantes dans ActionScript utilisent toutes des majuscules, avec des mots spars par le caractre de soulignement ( _ ). Par exemple, la dfinition de classe MouseEvent utilise cette convention dappellation pour ses constantes, dont chacune reprsente un vnement li une action de la souris :
package flash.events { public class MouseEvent extends Event { public static const CLICK:String = "click"; public static const DOUBLE_CLICK:String = "doubleClick"; public static const MOUSE_DOWN:String = "mouseDown"; public static const MOUSE_MOVE:String = "mouseMove"; ... } }
Oprateurs
Les oprateurs sont des fonctions spciales qui utilisent un ou plusieurs oprandes et renvoient une valeur. Un oprande est une valeur (gnralement un littral, une variable ou une expression) utilise par loprateur comme entre. Par exemple, dans le code suivant, les oprateurs daddition (+) et de multiplication (*) sont utiliss avec trois oprandes littraux (2, 3 et 4) pour renvoyer une valeur. Cette valeur est ensuite utilise par loprateur daffectation (=) pour attribuer la valeur renvoye, 14, la variable sumNumber.
var sumNumber:uint = 2 + 3 * 4; // uint = 14

68
Les oprateurs peuvent tre unaires, binaires ou ternaires. Un oprateur unaire utilise un oprande. Par exemple, loprateur dincrmentation (++) est un oprateur unaire car il utilise un seul oprande. Un oprateur binaire utilise deux oprandes. Par exemple, loprateur de division (/) utilise deux oprandes. Un oprateur ternaire utilise trois oprandes. Par exemple, loprateur conditionnel (?:) utilise trois oprandes. Certains oprateurs sont surchargs, ce qui signifie quils se comportent diffremment selon le type ou la quantit doprandes qui leur est transmis. Loprateur daddition (+) est un exemple doprateur surcharg qui se comporte diffremment selon le type de donnes des oprandes. Si les deux oprandes sont des nombres, loprateur daddition renvoie la somme des valeurs. Si les deux oprandes sont des chanes, loprateur daddition renvoie la concatnation des deux oprandes. Lexemple de code suivant indique comment loprateur se comporte diffremment selon les oprandes :
trace(5 + 5); // 10 trace("5" + "5"); // 55
Les oprateurs peuvent galement se comporter diffremment selon le nombre doprandes fourni. Loprateur de soustraction (-) est un oprateur la fois unaire et binaire. Lorsquil est fourni avec un seul oprande, loprateur de soustraction convertit loprande en valeur ngative et renvoie le rsultat. Lorsquil est fourni avec deux oprandes, loprateur de soustraction renvoie la diffrence entre les oprandes. Lexemple suivant prsente loprateur de soustraction utilis dabord comme oprateur unaire, puis comme oprateur binaire.
trace(-3); // -3 trace(7 - 2); // 5
Priorit et associativit des oprateurs

La priorit et lassociativit des oprateurs dterminent leur ordre de traitement. Bien quil soit vident, pour ceux qui connaissent bien larithmtique, que le compilateur traite loprateur de multiplication (*) avant loprateur daddition (+), le compilateur a besoin dinstructions claires quant lordre appliquer aux oprateurs. Lensemble de ces instructions est appel ordre de priorit des oprateurs. ActionScript dfinit une priorit par dfaut que loprateur parenthses (()) permet de modifier. Par exemple, le code suivant modifie la priorit par dfaut de lexemple prcdent pour forcer le compilateur traiter loprateur daddition avant loprateur de multiplication :
var sumNumber:uint = (2 + 3) * 4; // uint == 20
Il arrive que plusieurs oprateurs de mme priorit apparaissent dans la mme expression. Dans ce cas, le compilateur utilise les rgles dassociativit pour identifier le premier oprateur traiter. Tous les oprateurs binaires, sauf les oprateurs daffectation, sont associatifs gauche, ce qui signifie que les oprateurs de gauche sont traits avant ceux de droite. Les oprateurs daffectation et loprateur conditionnel (?:) sont associatifs droit, ce qui signifie que les oprateurs de droite sont traits avant ceux de gauche. Prenons par exemple les oprateurs infrieur (<) et suprieur (>), qui ont le mme ordre de priorit. Lorsque les deux oprateurs sont employs dans la mme expression, celui de gauche est trait en premier puisque tous deux sont associatifs gauche. Cela signifie que les deux instructions suivantes donnent le mme rsultat :
trace(3 > 2 < 1); // false trace((3 > 2) < 1); // false
Loprateur suprieur est trait en premier, ce qui donne une valeur true car loprande 3 est suprieur loprande 2. La valeur true est ensuite transmise loprateur infrieur , avec loprande 1. Le code suivant reprsente cet tat intermdiaire :
trace((true) < 1);
Loprateur Infrieur convertit la valeur true en la valeur numrique 1 et compare cette valeur numrique au second oprande 1 pour renvoyer la valeur false (la valeur 1 nest pas infrieure 1).

69
trace(1 < 1); // false
Vous pouvez modifier lassociativit gauche par dfaut avec loprateur parenthses. Vous pouvez demander au compilateur de traiter loprateur infrieur en premier lieu en plaant cet oprateur et son oprande entre parenthses. Lexemple suivant utilise loprateur parenthses pour produire un rsultat diffrent en utilisant les mmes nombres que lexemple prcdent :
trace(3 > (2 < 1)); // true
Loprateur infrieur est trait en premier, ce qui donne une valeur false car loprande 2 nest pas infrieur loprande 1. La valeur false est ensuite transmise loprateur suprieur , avec loprande 3. Le code suivant reprsente cet tat intermdiaire :
trace(3 > (false));
Loprateur suprieur convertit la valeur false en la valeur numrique 0 et compare cette valeur numrique lautre oprande 3 pour renvoyer la valeur true (la valeur 3 est suprieure 0).
trace(3 > 0); // true
Le tableau suivant rpertorie les oprateurs grs par ActionScript 3.0 par ordre de priorit dcroissant. Chaque ligne du tableau contient des oprateurs ayant la mme priorit. Chaque ligne doprateurs a une priorit suprieure la ligne situe au-dessous dans le tableau.
Groupe Principal Suffixe Unaire Multiplication Ajout Dcalage au niveau du bit Relationnel Egalit AND au niveau du bit XOR au niveau du bit OR au niveau du bit AND logique OR logique Conditionnel Affectation Virgule Oprateurs
[] {x:y} () f(x) new x.y x[y] <></> @ :: .. x++ x-++x --x + - ~ ! delete typeof void * / % + << >> >>> < > <= >= as in instanceof is == != === !== & ^ | && || ?: = *= /= %= += -= <<= >>= >>>= &= ^= |= ,
Oprateurs principaux
Les oprateurs principaux comprennent ceux utiliss pour crer des littraux Array et Object, regrouper des expressions, appeler des fonctions, instancier des occurrences de classe et accder des proprits.

70
Tous les oprateurs principaux, comme rpertoris dans le tableau suivant, ont la mme priorit. La mention (E4X) apparat en regard des oprateurs qui font partie de la spcification E4X.
Oprateur
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
Opration effectue Initialise un tableau Initialise un objet Regroupe des expressions Appelle une fonction Appelle un constructeur Accde une proprit Initialise un objet XMLList (E4X) Accde un attribut (E4X) Qualifie un nom (E4X) Accde un lment XML descendant (E4X)
Oprateurs de suffixe
Les oprateurs de suffixe prennent un oprateur et incrmentent ou dcrmentent sa valeur. Bien que ces oprateurs soient des oprateurs unaires, ils sont classs part du fait de leur priorit suprieure et de leur comportement particulier. Lorsque vous utilisez un oprateur de suffixe dans une expression plus grande, la valeur de lexpression est renvoye avant le traitement de cet oprateur. Par exemple, le code suivant montre comment la valeur de lexpression xNum++ est renvoye avant lincrmentation de la valeur :
var xNum:Number = 0; trace(xNum++); // 0 trace(xNum); // 1
Tous les oprateurs de suffixe, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
++ --
Opration effectue Incrmentation (suffixe) Dcrmentation (suffixe)
Oprateurs unaires
Les oprateurs unaires prennent un oprande. Les oprateurs dincrmentation (++) et de dcrmentation (--) de ce groupe sont des oprateurs de prfixe, cest--dire quils apparaissent avant loprande dans une expression. Les oprateurs de prfixe diffrent de leur quivalent suffixe car lopration dincrmentation ou de dcrmentation est effectue avant le renvoi de la valeur de lexpression globale. Par exemple, le code suivant montre comment la valeur de lexpression ++xNum est renvoye aprs lincrmentation de la valeur :
var xNum:Number = 0; trace(++xNum); // 1 trace(xNum); // 1
Tous les oprateurs unaires, comme rpertoris dans le tableau suivant, ont la mme priorit :

71
Oprateur
++ -+ ! ~ delete typeof void
Opration effectue Incrmentation (prfixe) Dcrmentation (prfixe) Unaire + Unaire - (ngation) NOT logique NOT au niveau du bit Supprime une proprit Renvoie les informations de type Renvoie une valeur non dfinie
Oprateurs de multiplication
Les oprateurs de multiplication prennent deux oprandes et effectuent des multiplications, des divisions ou des calculs de modulo. Tous les oprateurs de multiplication, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
* / %
Opration effectue Multiplication Division Modulo
Oprateurs dajout
Les oprateurs dajout prennent deux oprandes et effectuent des calculs daddition ou de soustraction. Tous les oprateurs dajout, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
+ -
Opration effectue Addition Soustraction
Oprateurs de dcalage au niveau du bit

Ces oprateurs prennent deux oprandes et dcalent les bits du premier selon la valeur spcifie dans le second. Tous les oprateurs de dcalage au niveau du bit, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
<< >> >>>
Opration effectue Dcalage gauche au niveau du bit Dcalage droit au niveau du bit Dcalage droit non sign au niveau du bit

72
Oprateurs relationnels
Les oprateurs relationnels prennent deux oprandes, comparent leurs valeurs et renvoient une valeur boolenne. Tous les oprateurs relationnels, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
< > <= >= as in instanceof is
Opration effectue Infrieur Suprieur Infrieur ou gal Suprieur ou gal Vrifie le type de donnes Vrifie les proprits des objets Vrifie la chane de prototype Vrifie le type de donnes
Oprateurs dgalit
Les oprateurs dgalit prennent deux oprandes, comparent leurs valeurs et renvoient une valeur boolenne. Tous les oprateurs dgalit, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
== != === !==
Opration effectue Egalit Ingalit Egalit stricte Ingalit stricte
Oprateurs logiques au niveau du bit

Ces oprateurs prennent deux oprandes et effectuent des oprations logiques au niveau des bits. La priorit de ces oprateurs diffre et ils sont prsents dans le tableau suivant par ordre dcroissant de priorit :
Oprateur
& ^ |
Opration effectue AND au niveau du bit XOR au niveau du bit OR au niveau du bit
Oprateurs logiques
Les oprateurs logiques prennent deux oprandes et renvoient une valeur boolenne. La priorit de ces oprateurs diffre et ils sont prsents dans le tableau suivant par ordre dcroissant de priorit :

73
Oprateur
&& ||
Opration effectue AND logique OR logique
Oprateur conditionnel
Loprateur conditionnel est un oprateur ternaire, cest--dire quil prend trois oprandes. Il correspond une mthode abrge de lapplication de linstruction conditionnelle if..else.
Oprateur
?:
Opration effectue Conditionnel
Oprateurs daffectation
Les oprateurs daffectation prennent deux oprandes et affectent une valeur lun deux en fonction de la valeur de lautre. Tous les oprateurs daffectation, comme rpertoris dans le tableau suivant, ont la mme priorit :
Oprateur
= *= /= %= += -= <<= >>= >>>= &= ^= |=
Opration effectue Affectation Affectation de multiplication Affectation de division Affectation modulo Affectation daddition Affectation de soustraction Affectation de dcalage gauche au niveau du bit Affectation de dcalage droit au niveau du bit Affectation de dcalage droit au niveau du bit non sign Affectation AND au niveau du bit Affectation XOR au niveau du bit Affectation OR au niveau du bit
Instructions conditionnelles
ActionScript 3.0 fournit trois instructions conditionnelles de base que vous pouvez utiliser pour contrler le flux du programme.
if..else
Linstruction conditionnelle if..else permet de tester une condition, puis dexcuter un bloc de code lorsque cette condition est positive et den excuter un autre dans le cas contraire. Par exemple, le code suivant vrifie si la valeur de x est suprieure 20 et gnre une fonction trace() dans laffirmative ou une autre fonction trace() dans le cas contraire :

74
if (x > 20) { trace("x is > 20"); } else { trace("x is <= 20"); }
Si vous ne souhaitez pas excuter un autre bloc de code, vous pouvez utiliser linstruction if sans linstruction else.
if..else if
Linstruction conditionnelle if..else if permet de tester plusieurs conditions. Par exemple, le code suivant teste non seulement si la valeur de x est suprieure 20, mais galement si la valeur de x est ngative :
if (x > 20) { trace("x is > 20"); } else if (x < 0) { trace("x is negative"); }
Si une instruction if ou else est suivie dune seule instruction, il est inutile de la placer entre accolades. Par exemple, le code suivant ne contient pas daccolades :
if (x > 0) trace("x else if (x < trace("x else trace("x is positive"); 0) is negative"); is 0");
Nanmoins, Adobe conseille de toujours utiliser des accolades car un comportement inattendu peut se produire si des instructions sont ajoutes ultrieurement une instruction conditionnelle sans accolades. Par exemple, dans le code suivant, la valeur de positiveNums augmente de 1 que la condition renvoie true ou non :
var x:int; var positiveNums:int = 0; if (x > 0) trace("x is positive"); positiveNums++; trace(positiveNums); // 1
switch
Linstruction switch est utile si vous avez plusieurs chemins dexcution sur la mme expression de condition. Elle sapparente une longue srie dinstructions if..else if, mais est plus lisible. Au lieu de tester une condition pour une valeur boolenne, linstruction switch value une expression et utilise le rsultat pour dterminer le bloc de code excuter. Les blocs de code commencent par une instruction case et se terminent par une instruction break. Par exemple, linstruction switch suivante imprime le jour de la semaine en fonction du numro du jour renvoy par la mthode Date.getDay() :

75
var someDate:Date = new Date(); var dayNum:uint = someDate.getDay(); switch(dayNum) { case 0: trace("Sunday"); break; case 1: trace("Monday"); break; case 2: trace("Tuesday"); break; case 3: trace("Wednesday"); break; case 4: trace("Thursday"); break; case 5: trace("Friday"); break; case 6: trace("Saturday"); break; default: trace("Out of range"); break; }
Boucles
Les instructions en boucle vous permettent dexcuter un bloc de code spcifique de faon rpte laide dune srie de valeurs ou de variables. Adobe recommande de toujours placer le bloc de code entre accolades ({}). Vous pouvez les omettre si le bloc de code contient une seule instruction mais, comme pour les instructions conditionnelles, cette pratique est dconseille : il est en effet possible que des instructions ajoutes une date ultrieure soient exclues du bloc de texte par inadvertance. Si vous ajoutez ultrieurement une instruction inclure dans le bloc de code mais que vous oubliez dajouter les accolades ncessaires, linstruction nest pas excute dans la boucle.
for
La boucle for vous permet de faire une itration sur une variable pour une plage de valeurs spcifique. Vous devez indiquer trois expressions dans une instruction for : une variable dfinie sur une valeur initiale, une instruction conditionnelle qui dtermine le moment o la boucle prend fin et une expression qui modifie la valeur de la variable avec chaque boucle. Par exemple, le code suivant boucle cinq reprises. La valeur de la variable i commence 0 et prend fin 4, et le rsultat est constitu par les nombres compris entre 0 et 4, chacun sur sa propre ligne.
var i:int; for (i = 0; i < 5; i++) { trace(i); }

76
for..in
La boucle for..in permet de faire une itration sur les proprits dun objet ou les lments dun tableau. Par exemple, utilisez la boucle for..in pour faire une itration sur les proprits dun objet gnrique (les proprits dun objet ntant pas conserves dans un ordre particulier, elles peuvent apparatre dans un ordre imprvisible) :
var myObj:Object = {x:20, y:30}; for (var i:String in myObj) { trace(i + ": " + myObj[i]); } // output: // x: 20 // y: 30
Vous pouvez galement faire une itration sur les lments dun tableau :
var myArray:Array = ["one", "two", "three"]; for (var i:String in myArray) { trace(myArray[i]); } // output: // one // two // three
En revanche, il est impossible ditrer sur les proprits dun objet lorsquil sagit dune occurrence de classe scelle (classe intgre ou dfinie par lutilisateur). Pour ce faire, la classe doit tre dynamique et, mme dans ce cas, vous ne pouvez faire ditration que sur les proprits ajoutes dynamiquement.
for each..in
La boucle for each..in vous permet de faire une itration sur les lments dune collection (balises dans un objet XML ou XMLList, valeurs des proprits dun objet ou lments dun tableau). Ainsi, comme lillustre lextrait suivant, vous pouvez utiliser une boucle for each..in pour itrer sur les proprits dun objet gnrique mais, contrairement la boucle for..in, la variable ditration dune boucle for each..in contient la valeur de la proprit plutt que le nom de celle-ci :
var myObj:Object = {x:20, y:30}; for each (var num in myObj) { trace(num); } // output: // 20 // 30
Vous pouvez faire une itration sur un objet XML ou XMLList, comme lindique lexemple suivant :

77
var myXML:XML = <users> <fname>Jane</fname> <fname>Susan</fname> <fname>John</fname> </users>; for each (var item in myXML.fname) { trace(item); } /* output Jane Susan John */
Vous pouvez galement faire une itration sur les lments dun tableau, comme lindique cet exemple :
var myArray:Array = ["one", "two", "three"]; for each (var item in myArray) { trace(item); } // output: // one // two // three
Vous ne pouvez pas faire une itration sur les proprits dun objet si ce dernier est une occurrence dune classe scelle. Mme pour les occurrences de classes dynamiques, vous ne pouvez pas faire une itration sur des proprits fixes qui sont des proprits dfinies comme faisant partie dune dfinition de classe.
while
La boucle while est semblable une instruction if qui se rpte tant que la condition est true. Par exemple, le code suivant produit le mme rsultat que lexemple de boucle for :
var i:int = 0; while (i < 5) { trace(i); i++; }
Lun des inconvnients que prsente la boucle while par rapport la boucle for est que les risques de boucles sans fin sont plus importants avec les boucles while. Par exemple, le code qui utilise la boucle for ne passe pas la compilation si vous omettez lexpression qui incrmente la variable du compteur, alors que le code qui utilise la boucle while est compil. Et sans lexpression qui incrmente i, la boucle se poursuit sans fin.
do..while
La boucle do..while est une boucle while qui garantit que le bloc de code est excut au moins une fois, car la condition est vrifie une fois que le bloc de code est excut. Le code suivant est un exemple simple dune boucle do..while qui renvoie une sortie mme si la condition nest pas remplie.

78
var i:int = 5; do { trace(i); i++; } while (i < 5); // output: 5
Fonctions
Les fonctions sont des blocs de code qui effectuent des tches spcifiques et qui peuvent tre rutiliss dans votre programme. Il existe deux types de fonctions dans ActionScript 3.0 : les mthodes et les fonctions closure. Une fonction est appele mthode ou fonction closure selon le contexte dans lequel elle est dfinie. Une fonction est appele mthode si vous la dfinissez comme partie dune dfinition de classe ou lassociez loccurrence dun objet. Une fonction est appele fonction closure si elle est dfinie de toute autre faon. Les fonctions ont toujours t trs importantes dans ActionScript. Dans ActionScript 1.0, par exemple, le mot-cl
class nexistait pas. Par consquent, les classes taient dfinies par des fonctions constructeurs. Mme si le mot-cl class a depuis t ajout au langage, une solide comprhension des fonctions reste importante si vous souhaitez
bnficier de tous les avantages du langage. Ceci peut tre un dfi pour les programmeurs qui sattendent ce que les fonctions ActionScript se comportent de faon identique celles des langages tels que C++ ou Java. Mme si lappel et la dfinition des fonctions de base ne devraient pas constituer un dfi pour les programmeurs expriments, certaines des fonctions ActionScript les plus avances ncessitent une explication.
Concepts des fonctions de base

Appel de fonctions Vous appelez une fonction en utilisant son identifiant suivi de loprateur parenthses (()). Vous placez les paramtres de fonction que vous souhaitez envoyer la fonction entre parenthses laide de loprateur parenthses. Par exemple, la fonction trace() est une fonction de haut niveau dans ActionScript 3.0 :
trace("Use trace to help debug your script");
Si vous appelez une fonction sans paramtres, vous devez utiliser une paire de parenthses vide. Par exemple, vous pouvez utiliser la mthode Math.random(), qui ne prend aucun paramtre, pour gnrer un nombre alatoire :
var randomNum:Number = Math.random();
Dfinition de vos fonctions Dans ActionScript 3.0, deux techniques vous permettent de dfinir une fonction : vous pouvez utiliser une instruction de fonction ou une expression de fonction. La technique que vous choisissez dpend du style de programmation que vous prfrez, plus statique ou dynamique. Dfinissez vos fonctions laide dinstructions de fonction si vous prfrez une programmation en mode strict, ou statique. Dfinissez vos fonctions laide dexpressions de fonction si vous en avez vraiment besoin. Les expressions de fonction sont utilises plus souvent dans la programmation en mode standard, ou dynamique.

79
Instructions de fonction Les instructions de fonction reprsentent la technique privilgie pour dfinir des fonctions en mode strict. Une instruction de fonction commence par le mot-cl function, suivi :
du nom de la fonction ; des paramtres, dans une liste spare par des virgules, place entre parenthses ; du corps de la fonction, cest--dire le code ActionScript excuter lors de lappel de la fonction, plac entre
accolades. Par exemple, le code suivant cre une fonction qui dfinit un paramtre puis appelle la fonction laide de la chane hello comme valeur de paramtre :
function traceParameter(aParam:String) { trace(aParam); } traceParameter("hello"); // hello
Expressions de fonction La deuxime faon de dclarer une fonction est dutiliser une instruction daffectation avec une expression de fonction, parfois appele littral de fonction ou fonction anonyme. Il sagit dune mthode plus dtaille largement utilise dans les versions prcdentes dActionScript. Une instruction daffectation associe une expression de fonction commence par le mot-cl var, suivi :
du nom de la fonction ; de loprateur deux points (.) ; de la classe Function pour indiquer le type de donnes ; de loprateur daffectation (=) ; du mot-cl function ; des paramtres, dans une liste spare par des virgules, place entre parenthses ; du corps de la fonction, cest--dire le code ActionScript excuter lors de lappel de la fonction, plac entre
accolades. Par exemple, le code suivant dclare la fonction traceParameter laide dune expression de fonction :
var traceParameter:Function = function (aParam:String) { trace(aParam); }; traceParameter("hello"); // hello
Vous remarquerez que vous ne spcifiez pas de nom de fonction, comme dans une instruction de fonction. Une autre diffrence importante entre les expressions de fonction et les instructions de fonction est quune expression de fonction est plus une expression quune instruction. Ceci signifie quune expression de fonction ne peut pas tre utilise seule, contrairement une instruction de fonction. Une expression de fonction peut tre utilise uniquement en tant que partie dune instruction, gnralement une instruction daffectation. Lexemple suivant reprsente une expression de fonction affecte un lment de tableau :

80
var traceArray:Array = new Array(); traceArray[0] = function (aParam:String) { trace(aParam); }; traceArray[0]("hello");
Choix dinstructions ou dexpressions En rgle gnrale, utilisez une instruction de fonction, moins que des circonstances spcifiques nexigent lutilisation dune expression. Les instructions de fonction sont moins dtailles et renforcent plus la cohrence entre le mode strict et le mode standard que les expressions de fonction. Les instructions de fonction sont plus lisibles que les instructions daffectation qui contiennent des expressions de fonction. Les instructions de fonction rendent votre code plus concis ; elles prtent moins confusion que les expressions de fonction, qui exigent lutilisation des mots-cls var et function. Les instructions de fonction renforcent la cohrence entre les deux modes de compilateur car vous pouvez utiliser la syntaxe point en mode strict et en mode standard pour appeler une mthode dclare laide dune instruction de fonction. Ceci ne sapplique pas ncessairement aux mthodes dclares avec une expression de fonction. Par exemple, le code suivant dfinit la classe Example laide de deux mthodes : methodExpression(), qui est dclare par le biais dune expression de fonction, et methodStatement(), qui est dclare par le biais dune instruction de fonction. En mode strict, vous ne pouvez pas utiliser la syntaxe point pour appeler la mthode methodExpression().
class Example { var methodExpression = function() {} function methodStatement() {} } var myEx:Example = new Example(); myEx.methodExpression(); // error in strict mode; okay in standard mode myEx.methodStatement(); // okay in strict and standard modes
Les expressions de fonction sont plus adaptes la programmation cible sur un comportement dexcution ou dynamique. Si vous prfrez utiliser le mode strict mais que vous souhaitez galement appeler une mthode dclare avec une expression de fonction, vous pouvez utiliser lune des deux techniques. Premirement, vous pouvez appeler la mthode laide de loprateur crochets ([]) au lieu de loprateur point (.). Lappel de mthode suivant a lieu la fois en mode strict et en mode standard :
myExample["methodLiteral"]();
Deuximement, vous pouvez dclarer la classe entire comme classe dynamique. Mme si ceci vous permet dappeler la mthode laide de loprateur point, linconvnient est que vous sacrifiez une fonctionnalit de mode strict pour toutes les occurrences de cette classe. Par exemple, le compilateur ne gnre pas derreur si vous tentez daccder une proprit non dfinie sur une occurrence dune classe dynamique. Les expressions de fonction peuvent tre utiles dans certains cas. Elles sont couramment utilises pour des fonctions qui sont utilises une seule fois. Elles peuvent tre utilises galement pour associer une fonction une proprit de prototype. Pour plus dinformations, voir Objet prototype.

81
Il existe deux lgres diffrences entre les instructions de fonction et les expressions de fonction dont il faut tenir compte lorsque vous choisissez la technique utiliser. La premire rside dans le fait que les expressions de fonction nexistent pas indpendamment en tant quobjets en ce qui concerne la gestion de la mmoire et le nettoyage. En dautres termes, lorsque vous affectez une expression de fonction un autre objet (un lment de tableau ou une proprit dobjet, par exemple) vous crez lunique rfrence cette expression de fonction dans votre code. Si le tableau ou lobjet auquel est associe lexpression de fonction nest plus disponible, vous navez plus accs lexpression de fonction. Si le tableau ou lobjet est supprim, la mmoire que lexpression de fonction utilise peut tre nettoye, ce qui signifie quelle peut tre rutilise dautres fins. Lexemple suivant indique que pour une expression de fonction, la fonction nest plus disponible une fois que la proprit laquelle lexpression est affecte est supprime. La classe Test est dynamique, ce qui signifie que vous pouvez ajouter une proprit appele functionExp qui contient une expression de fonction. La fonction functionExp() peut tre appele avec loprateur point, mais une fois que la proprit functionExp est supprime, la fonction nest plus accessible.
dynamic class Test {} var myTest:Test = new Test(); // function expression myTest.functionExp = function () { trace("Function expression") }; myTest.functionExp(); // Function expression delete myTest.functionExp; myTest.functionExp(); // error
Si, en revanche, la fonction est dabord dfinie avec une instruction de fonction, elle existe comme son propre objet et continue exister, mme une fois que vous avez supprim la proprit laquelle elle est associe. Loprateur delete fonctionne uniquement sur les proprits dobjets, donc mme un appel supprimer la fonction stateFunc() ne fonctionne pas.
dynamic class Test {} var myTest:Test = new Test(); // function statement function stateFunc() { trace("Function statement") } myTest.statement = stateFunc; myTest.statement(); // Function statement delete myTest.statement; delete stateFunc; // no effect stateFunc();// Function statement myTest.statement(); // error
La deuxime diffrence entre les instructions de fonction et les expressions de fonction rside dans le fait que les instructions de fonction existent dans le cadre dans lequel elles sont dfinies, notamment les instructions qui apparaissent avant linstruction de fonction. Les expressions de fonction, en revanche, sont dfinies uniquement pour les instructions ultrieures. Par exemple, le code suivant appelle la fonction scopeTest() avant quelle soit dfinie :
statementTest(); // statementTest function statementTest():void { trace("statementTest"); }
Les expressions de fonction ne sont pas disponibles avant dtre dfinies. Par consquent, le code suivant provoque une erreur dexcution :

82
expressionTest(); // run-time error var expressionTest:Function = function () { trace("expressionTest"); }
Renvoi de valeurs des fonctions Pour renvoyer une valeur de votre fonction, utilisez linstruction return suivie de lexpression ou de la valeur littrale que vous souhaitez renvoyer. Par exemple, le code suivant renvoie une expression reprsentant le paramtre :
function doubleNum(baseNum:int):int { return (baseNum * 2); }
Vous remarquerez que linstruction return termine la fonction, de sorte que les instructions suivant une instruction return ne sont pas excutes, comme suit :
function doubleNum(baseNum:int):int { return (baseNum * 2); trace("after return"); // This trace statement will not be executed. }
En mode strict, vous devez renvoyer une valeur du type appropri si vous choisissez de spcifier un type de renvoi. Par exemple, le code suivant gnre une erreur en mode strict car il ne renvoie pas de valeur valide :
function doubleNum(baseNum:int):int { trace("after return"); }
Fonctions imbriques Vous pouvez imbriquer des fonctions, ce qui signifie que vous pouvez dclarer des fonctions au sein dautres fonctions. Une fonction imbrique est disponible uniquement dans sa fonction parent, moins quune rfrence la fonction ne soit transmise un code externe. Par exemple, le code suivant dclare deux fonctions imbriques lintrieur de la fonction getNameAndVersion() :
function getNameAndVersion():String { function getVersion():String { return "10"; } function getProductName():String { return "Flash Player"; } return (getProductName() + " " + getVersion()); } trace(getNameAndVersion()); // Flash Player 10
Lorsque des fonctions imbriques sont transmises un code externe, elles le sont en tant que fonctions closure, ce qui signifie que la fonction conserve les dfinitions se trouvant dans le domaine au moment de la dfinition de la fonction. Pour plus dinformations, voir Domaine dune fonction.

83
Paramtres de fonction
ActionScript 3.0 permet dexploiter des paramtres de fonction qui peuvent sembler nouveaux pour les programmeurs qui dcouvrent le langage. Bien que la plupart des programmeurs connaissent le principe de transfert de paramtres par valeur ou rfrence, lobjet arguments et le paramtre ... (rest) seront peut-tre des nouveauts. Transfert darguments par valeur ou par rfrence Dans de nombreux langages de programmation, il est important de comprendre la diffrence entre le transfert darguments par valeur ou par rfrence car elle peut affecter la faon dont le code est conu. Transfrer par valeur signifie que la valeur de largument est copie dans une variable locale pour tre utilise dans la fonction. Transfrer par rfrence signifie que seule une rfrence largument est transmise, au lieu de la valeur relle. Aucune copie de largument rel nest effectue. A la place, une rfrence la variable transfre en tant quargument est cre et affecte une variable locale pour tre utilise dans la fonction. En tant que rfrence une variable en dehors de la fonction, la variable locale vous permet de modifier la valeur de la variable dorigine. Dans ActionScript 3.0, tous les arguments sont transfrs par rfrence car toutes les valeurs sont stockes en tant quobjets. Nanmoins, les objets qui appartiennent aux types de donnes primitifs (Boolean, Number, int, uint et String) possdent des oprateurs spciaux qui font quils se comportent comme sils taient transfrs par valeur. Par exemple, le code suivant cre une fonction appele passPrimitives() qui dfinit deux paramtres appels xParam et yParam de type int. Ces paramtres sont identiques aux variables locales dclares dans le corps de la fonction passPrimitives(). Lorsque la fonction est appele avec les arguments xValue et yValue, les paramtres xParam et yParam sont initialiss avec des rfrences aux objets int reprsents par xValue et yValue. Les arguments se comportent comme sils taient transfrs par valeur car ils sont primitifs. Bien que xParam et yParam contiennent initialement des rfrences aux objets xValue et yValue uniquement, toute modification apporte aux variables dans le corps de fonction gnre de nouvelles copies des valeurs dans la mmoire.
function passPrimitives(xParam:int, yParam:int):void { xParam++; yParam++; trace(xParam, yParam); } var xValue:int = 10; var yValue:int = 15; trace(xValue, yValue);// 10 15 passPrimitives(xValue, yValue); // 11 16 trace(xValue, yValue);// 10 15
Dans la fonction passPrimitives(), les valeurs de xParam et yParam sont incrmentes, mais ceci naffecte pas les valeurs de xValue et yValue, comme indiqu dans la dernire instruction trace. Ceci sapplique mme si les paramtres portent les mmes noms que les variables, xValue et yValue, car les xValue et yValue se trouvant dans la fonction pointeraient vers de nouveaux emplacements dans la mmoire qui existent indpendamment des variables du mme nom en dehors de la fonction. Tous les autres objets (cest--dire les objets qui nappartiennent pas aux types de donnes primitifs) sont toujours transfrs par rfrence, ce qui vous permet de modifier la valeur de la variable dorigine. Par exemple, le code suivant cre un objet appel objVar avec deux proprits, x et y. Lobjet est transfr en tant quargument la fonction passByRef(). Etant donn que lobjet nest pas un type primitif, non seulement il est transfr par rfrence mais il reste galement une rfrence. Les changements apports aux paramtres dans la fonction affectent donc les proprits dobjet en dehors de la fonction.

84
function passByRef(objParam:Object):void { objParam.x++; objParam.y++; trace(objParam.x, objParam.y); } var objVar:Object = {x:10, y:15}; trace(objVar.x, objVar.y); // 10 15 passByRef(objVar); // 11 16 trace(objVar.x, objVar.y); // 11 16
Le paramtre objParam rfrence le mme objet que la variable globale objVar. Comme vous pouvez le constater dans les instructions trace de lexemple, les modifications apportes aux proprits x et y de lobjet objParam sont visibles dans lobjet objVar. Valeurs de paramtre par dfaut Dans ActionScript 3.0, vous pouvez dclarer des valeurs de paramtre par dfaut pour une fonction. Si un appel une fonction avec des valeurs de paramtre par dfaut omet un paramtre avec des valeurs par dfaut, la valeur spcifie dans la dfinition de fonction pour ce paramtre est utilise. Tous les paramtres avec des valeurs par dfaut doivent tre placs la fin de la liste des paramtres. Les valeurs affectes comme valeurs par dfaut doivent tre des constantes de compilation. Lexistence dune valeur par dfaut pour un paramtre le rend facultatif. Un paramtre sans valeur par dfaut est considr comme un paramtre obligatoire. Par exemple, le code suivant cre une fonction avec trois paramtres, dont deux possdent des valeurs par dfaut. Lorsque la fonction est appele avec un seul paramtre, les valeurs par dfaut des paramtres sont utilises.
function defaultValues(x:int, y:int = 3, z:int = 5):void { trace(x, y, z); } defaultValues(1); // 1 3 5
Objet arguments Lorsque les paramtres sont transfrs une fonction, vous pouvez utiliser lobjet arguments pour accder aux informations concernant les paramtres transfrs votre fonction. Voici certains aspects importants de lobjet arguments :
Lobjet arguments est un tableau qui comprend tous les paramtres transfrs la fonction. La proprit arguments.length indique le nombre de paramtres transmis la fonction. La proprit arguments.callee fournit une rfrence la fonction elle-mme, ce qui est utile pour les appels
rcursifs des expressions de fonction. Remarque : lobjet arguments nest pas disponible si un paramtre est appel arguments ou si vous utilisez le paramtre ... (rest). Si lobjet arguments est rfrenc dans le corps dune fonction, ActionScript 3.0 permet aux appels de fonction dinclure plus de paramtres que ceux dfinis dans la dfinition de fonction. Mais il gnre une erreur de compilateur en mode strict si le nombre de paramtres ne correspond pas au nombre de paramtres obligatoires (et, ventuellement, au nombre de paramtres facultatifs). Vous pouvez utiliser laspect de tableau de lobjet arguments pour accder aux paramtres transfrs la fonction, que ces paramtres soient dfinis ou non dans la dfinition de fonction. Lexemple suivant, qui est uniquement compil en mode standard, utilise le tableau arguments et la proprit arguments.length pour suivre tous les paramtres transfrs la fonction traceArgArray() :

85
function traceArgArray(x:int):void { for (var i:uint = 0; i < arguments.length; i++) { trace(arguments[i]); } } traceArgArray(1, 2, 3); // // // // output: 1 2 3
La proprit arguments.callee est souvent utilise dans des fonctions anonymes pour crer une rcursivit. Vous pouvez lutiliser pour ajouter de la flexibilit votre code. Si le nom de la fonction rcursive change pendant votre cycle de dveloppement, il est inutile de modifier lappel rcursif dans le corps de votre fonction si vous utilisez arguments.callee au lieu du nom de fonction. La proprit arguments.callee est utilise dans lexpression de fonction suivante pour activer la rcursivit :
var factorial:Function = function (x:uint) { if(x == 0) { return 1; } else { return (x * arguments.callee(x - 1)); } } trace(factorial(5)); // 120
Si vous utilisez le paramtre ... (rest) dans la dclaration de fonction, lobjet arguments nest pas disponible. Vous devez accder aux paramtres laide des noms de paramtre que vous avez dclars. Nutilisez pas la chane "arguments" comme nom de paramtre car elle masque lobjet arguments. Par exemple, si la fonction traceArgArray() est rcrite de faon ce quun paramtre arguments soit ajout, les rfrences arguments dans le corps de la fonction se rfrent au paramtre plutt qu lobjet arguments. Le code suivant donne le rsultat :
function traceArgArray(x:int, arguments:int):void { for (var i:uint = 0; i < arguments.length; i++) { trace(arguments[i]); } } traceArgArray(1, 2, 3); // no output

86
Lobjet arguments des versions prcdentes dActionScript contenait galement une proprit appele caller, qui est une rfrence la fonction qui appelait la fonction actuelle. La proprit caller nexiste pas dans ActionScript 3.0, mais si vous avez besoin dune rfrence la fonction dappel, vous pouvez modifier celle-ci de faon ce quelle transfre un paramtre supplmentaire qui en soit une rfrence. Paramtre ... (rest) ActionScript 3.0 prsente une nouvelle dclaration de paramtre appele le paramtre .. (rest). Ce paramtre vous permet de spcifier un paramtre de tableau qui accepte nimporte quel nombre darguments spars par des virgules. Veillez ne pas inclure un mot rserv dans le nom du paramtre. Cette dclaration de paramtre doit tre le dernier paramtre spcifi. Ce paramtre rend lobjet arguments non disponible. Bien que le paramtre ... (rest) offre la mme fonctionnalit que le tableau arguments et la proprit arguments.length, il ne fournit pas la mme fonctionnalit que la proprit arguments.callee. Vrifiez que vous navez pas besoin dutiliser arguments.callee avant dutiliser le paramtre ... (rest). Lexemple suivant rcrit la fonction traceArgArray() laide du paramtre ... (rest) plutt que de lobjet arguments :
function traceArgArray(... args):void { for (var i:uint = 0; i < args.length; i++) { trace(args[i]); } } traceArgArray(1, 2, 3); // // // // output: 1 2 3
Le paramtre ... (rest) peut galement tre utilis avec dautres paramtres, sous rserve quil soit le dernier de la liste. Lexemple suivant modifie la fonction traceArgArray() de faon ce que son premier paramtre, x, soit de type int, et que le second utilise le paramtre ... (rest). Le rsultat ignore la premire valeur car le premier paramtre ne fait plus partie du tableau cr par le paramtre ... (rest).
function traceArgArray(x: int, ... args) { for (var i:uint = 0; i < args.length; i++) { trace(args[i]); } } traceArgArray(1, 2, 3); // output: // 2 // 3

87
Fonctions comme objets

Dans ActionScript 3.0, les fonctions sont des objets. Lorsque vous crez une fonction, vous crez un objet qui peut non seulement tre transmis en tant que paramtre une autre fonction, mais auquel sont galement associes des proprits et des mthodes. Les fonctions transfres en tant quarguments une autre fonction sont transmises par rfrence et non par valeur. Lorsque vous transfrez une fonction en tant quargument, vous utilisez uniquement lidentifiant et non loprateur parenthses qui permet dappeler la mthode. Par exemple, le code suivant transfre une fonction appele clickListener() en tant quargument la mthode addEventListener() :
addEventListener(MouseEvent.CLICK, clickListener);
Mme si cela peut sembler trange pour les programmeurs dcouvrant ActionScript, les fonctions peuvent avoir des proprits et des mthodes, comme les objets. Chaque fonction a en ralit une proprit en lecture seule appele length qui stocke le nombre de paramtres dfinis pour la fonction. Ceci est diffrent de la proprit arguments.length qui indique le nombre darguments envoys la fonction. Dans ActionScript, le nombre darguments envoys une fonction peut dpasser le nombre de paramtres dfinis pour cette dernire. Lexemple suivant (qui compile uniquement en mode standard car le mode strict exige une correspondance exacte entre le nombre darguments transfrs et le nombre de paramtres dfinis) illustre la diffrence entre les deux proprits :
// Compiles only in standard mode function traceLength(x:uint, y:uint):void { trace("arguments received: " + arguments.length); trace("arguments expected: " + traceLength.length); } traceLength(3, 5, 7, 11); /* output: arguments received: 4 arguments expected: 2 */
En mode standard, vous pouvez dfinir vos proprits en dehors du corps de la fonction. Les proprits de fonction peuvent servir de proprits quasi statiques vous permettant de sauvegarder ltat dune variable lie la fonction. Par exemple, vous pouvez suivre le nombre dappels dune fonction particulire. Une telle fonctionnalit peut tre utile si vous crivez un jeu et souhaitez suivre le nombre de fois quun utilisateur se sert dune certaine commande (vous pouvez galement utiliser une proprit de classe statique). Lexemple suivant (qui compile uniquement en mode standard car le mode strict nautorise pas lajout de proprits dynamiques aux fonctions) cre une proprit de fonction en dehors de la dclaration de la fonction et incrmente cette proprit chaque appel de la fonction :
// Compiles only in standard mode var someFunction:Function = function ():void { someFunction.counter++; } someFunction.counter = 0; someFunction(); someFunction(); trace(someFunction.counter); // 2

88
Domaine dune fonction

Le domaine dune fonction dtermine non seulement lendroit o cette fonction peut tre appele dans un programme, mais galement les dfinitions auxquelles la fonction peut accder. Les mmes rgles de domaine qui sappliquent aux identifiants de variable sappliquent aux identifiants de fonction. Une fonction dclare dans le domaine global est disponible dans tout votre code. Par exemple, ActionScript 3.0 contient des fonctions globales (isNaN() et parseInt(), par exemple) disponibles nimporte o dans votre code. Une fonction imbrique (une fonction dclare dans une autre fonction) peut tre utilise nimporte o dans la fonction dans laquelle elle a t dclare. Chane de domaine Chaque fois quune fonction commence une excution, des objets et des proprits sont crs. Premirement, un objet spcial appel objet dactivation est cr. Il stocke les paramtres et les variables locales ou fonctions dclares dans le corps de la fonction. Vous ne pouvez pas accder directement lobjet dactivation car il sagit dun mcanisme interne. Deuximement, une chane de domaine est cre. Elle contient une liste ordonne dobjets dans laquelle le moteur dexcution recherche des dclarations didentifiant. Chaque fonction qui sexcute a une chane de domaine stocke dans une proprit interne. Dans le cas dune fonction imbrique, la chane de domaine commence avec son objet dactivation, suivi par lobjet dactivation de sa fonction parent. La chane continue de cette faon jusqu ce que lobjet global soit atteint. Lobjet global est cr lorsquun programme ActionScript commence, et contient toutes les fonctions et les variables globales. Fonctions closure Une fonction closure est un objet qui contient un instantan dune fonction et de son environnement lexical. Lenvironnement lexical dune fonction comprend toutes les variables, proprits, mthodes et les objets dans la chane de domaine de la fonction, ainsi que leurs valeurs. Les fonctions closure sont cres chaque fois quune fonction est excute part dun objet ou dune classe. Le fait que les fonctions closure conservent le domaine dans lequel elles ont t dfinies cre des rsultats intressants lorsquune fonction est transfre en tant quargument ou valeur de renvoi dans un domaine diffrent. Par exemple, le code suivant cre deux fonctions : foo(), qui renvoie une fonction imbrique appele rectArea() qui calcule la surface dun rectangle, et bar(), qui appelle foo() et stocke la fonction closure renvoye dans une variable appele myProduct. Mme si la fonction bar() dfinit sa propre variable locale x (avec une valeur de 2), lorsque la fonction closure myProduct() est appele, elle conserve la variable x (avec une valeur de 40) dfinie dans la fonction foo(). La fonction bar() renvoie par consquent la valeur 160 au lieu de 8.
function foo():Function { var x:int = 40; function rectArea(y:int):int // function closure defined { return x * y } return rectArea; } function bar():void { var x:int = 2; var y:int = 4; var myProduct:Function = foo(); trace(myProduct(4)); // function closure called } bar(); // 160

89
Les mthodes se comportent de la mme faon car elles conservent galement les informations concernant lenvironnement lexical dans lequel elles ont t cres. Cette caractristique se remarque plus particulirement lorsquune mthode est extraite de son occurrence, ce qui cre une mthode lie. La diffrence principale entre une fonction closure et une mthode lie est que la valeur du mot-cl this dans une mthode lie se rfre toujours loccurrence laquelle elle tait associe lorigine, alors que dans une fonction closure, la valeur du mot-cl this peut changer.
90
Chapitre 4 : Programmation oriente objets en ActionScript

Introduction la programmation oriente objets
La programmation oriente objets (POO) est une technique dorganisation du code dun programme en le groupant en objets. Les objets sont ici des lments individuels comportant des informations (valeurs de donnes) et des fonctionnalits. Lapproche oriente objet permet de regrouper des lments particuliers dinformations avec des fonctionnalits ou des actions communes associes ces informations. Vous pourriez, par exemple, regrouper les informations dun enregistrement musical (titre de lalbum, titre de la piste ou nom de lartiste) avec des fonctionnalits comme lajout de la piste une liste de lecture ou la lecture de tous les enregistrement de cet artiste. Ces lments sont rassembls en un seul lment, lobjet (par exemple, un album ou une piste ). La possibilit dintgrer ainsi toutes ces valeurs et ces fonctions offre divers avantages : il est possible de nutiliser quune seule variable plutt que plusieurs dentre elles, ainsi que de regrouper des fonctionnalits lies entre elles. La combinaison des informations et des fonctionnalits permet de structurer les programmes pour quils se rapprochent davantage du fonctionnement humain.
Classes
Une classe est une reprsentation abstraite dun objet. Une classe conserve des informations sur les types de donnes contenues par un objet et sur les comportements possibles de cet objet. Lutilit de ce niveau dabstraction peut ne pas tre vidente dans le cas de petits scripts ne contenant que quelques objets destins interagir les uns avec les autres. Cependant, au fur et mesure quun programme crot en ampleur, le nombre dobjets grer augmente. Les classes autorisent alors un meilleur contrle sur la cration des objets et sur leurs interactions. Ds la premire version dActionScript, les programmeurs en ActionScript pouvaient utiliser des objets Function pour crer des lments ressemblant des classes. ActionScript 2.0 a ensuite ajout une prise en charge formelle des classes, avec des mots-cls tels que class et extends. De son ct, ActionScript 3.0 prserve la prise en charge des mots-cls introduits avec ActionScript 2.0, tout en ajoutant de nouvelles possibilits : par exemple un meilleur contrle daccs avec les attribut protected et internal, ainsi quun meilleur contrle de lhritage avec les mots-cls final et override. Si vous avez dj cr des classes dans des langages de programmation tels que Java, C++ ou C#, vous ne serez pas dpays par ActionScript. ActionScript partage avec ces langages de nombreux mots-cls et noms dattributs, comme classe, extends et public. Remarque : dans la documentation Adobe ActionScript, le terme proprit dsigne tout membre dun objet ou dune classe (variables, constantes et mthodes). En outre, bien que les termes classe et statique soient frquemment utiliss indiffremment, nous ferons une distinction entre ces termes. Par exemple, lexpression proprits de classe dsigne tous les membres dune classe plutt que ses membres statiques exclusivement.

Programmation oriente objets en ActionScript
91
Dfinitions de classe
En ActionScript 3.0, les dfinitions de classe utilisent la mme syntaxe quen ActionScript 2.0. La syntaxe correcte dune dfinition de classe utilise le mot-cl class suivi du nom de la classe. Le corps de la dfinition de classe est insr entre des accolades ({}) aprs le nom de la classe. Par exemple, le code suivant cre une classe appele Shape qui contient une variable appele visible :
public class Shape { var visible:Boolean = true; }
Notez que la syntaxe est diffrente dans le cas des dfinitions de classe faisant partie dun package. En ActionScript 2.0, si une classe fait partie dun package, le nom de ce dernier doit figurer dans la dclaration de classe. Comme linstruction package a t introduite en ActionScript 3.0, le nom du package doit figurer dans la dclaration de package et non pas dans la dclaration de classe. Par exemple, les dclarations de classe suivantes montrent comment la classe BitmapData, qui fait partie du package flash.display, est dfinie dans ActionScript 2.0 et ActionScript 3.0 :
// ActionScript 2.0 class flash.display.BitmapData {} // ActionScript 3.0 package flash.display { public class BitmapData {} }
Attributs de classe ActionScript 3.0 vous permet de modifier des dfinitions de classe laide de lun des quatre attributs suivants :
Attribut
dynamique final interne (par dfaut) public
Dfinition Permet dajouter des proprits aux occurrences lors de lexcution. Ne doit pas tre tendue par une autre classe. Visible pour les rfrences partir du package actuel. Visible pour les rfrences partir de nimporte quel point du code.
Pour chacun de ces attributs, lexception dinternal, vous incluez explicitement lattribut pour obtenir le comportement qui lui est associ. Par exemple, faute dinclure lattribut dynamic lors de la dfinition dune classe, vous ntes pas en mesure dajouter des proprits une occurrence de classe lors de lexcution. Pour affecter explicitement un attribut, placez-le au dbut de la dfinition de la classe, comme dans le code ci-dessous :
dynamic class Shape {}
Notez que la liste ne contient pas dattribut appel abstract. En effet, les classes abstraites ne sont pas prises en charge en ActionScript 3.0. Notez galement que la liste ne comprend pas non plus les attributs private et protected. Ces attributs nont de signification quau sein dune dfinition de classe et ne peuvent tre appliqus aux classes ellesmmes. Si vous ne souhaitez pas quune classe soit visible hors de son package, placez-la au sein dun package et affectez la classe de lattribut internal. Autrement, vous pouvez omettre les attributs internal et public et le compilateur ajoutera automatiquement lattribut internal pour vous. Vous pouvez galement dfinir une classe afin quelle soit uniquement visible lintrieur du fichier source dans lequel elle est dfinie. Pour ce faire, placez-la la fin de ce fichier source, aprs laccolade de fin de la dfinition du package.

92
Corps de la classe Le corps de la classe, qui est entour daccolades, dfinit les variables, les constantes et les mthodes de la classe. Lexemple suivant illustre la dclaration de la classe Accessibility dans ActionScript 3.0 :
public final class Accessibility { public static function get active():Boolean; public static function updateProperties():void; }
Vous pouvez aussi dfinir un espace de noms au sein dun corps de classe. Lexemple suivant montre la dfinition dun espace de noms dans le corps dune classe et son utilisation comme attribut dune mthode de cette classe :
public class SampleClass { public namespace sampleNamespace; sampleNamespace function doSomething():void; }
ActionScript 3.0 vous permet dinclure dans un corps de classe non seulement des dfinitions, mais galement des instructions. Les instructions qui figurent dans le corps dune classe, mais hors dune dfinition de mthode, sont excutes une seule fois, lors de la premire apparition de la dfinition de classe et de la cration de lobjet class qui lui est associ. Lexemple suivant comprend un appel vers une fonction externe, hello() et une instruction trace qui affiche un message de confirmation lorsque la classe est dfinie.
function hello():String { trace("hola"); } class SampleClass { hello(); trace("class created"); } // output when class is created hola class created
En ActionScript 3.0, il est permis de dfinir une proprit statique et une proprit doccurrence portant le mme nom dans le corps de la mme classe. Par exemple, le code suivant dclare une variable statique appele message et une variable doccurrence du mme nom :
class StaticTest { static var message:String = "static variable"; var message:String = "instance variable"; } // In your script var myST:StaticTest = new StaticTest(); trace(StaticTest.message); // output: static variable trace(myST.message); // output: instance variable

93
Attributs de proprit de classe

Dans le cadre du modle dobjet ActionScript, le terme proprit reprsente tout ce qui peut tre membre dune classe : variables, constantes et mthodes. Ce terme est utilis de manire plus restrictive dans le manuel Guide de rfrence du langage et des composants ActionScript 3.0 : il ne dsigne alors que les membres dune classe qui sont des variables ou qui sont dfinis par une mthode de lecture/dfinition. En ActionScript 3.0, il existe un jeu dattributs qui peut tre utilis avec nimporte quelle proprit de classe. Le tableau suivant prsente ce jeu dattributs.
Attribut
internal (par dfaut) private protected public static UserDefinedNamespace
Dfinition Visible pour les rfrences au sein dun mme package. Visible pour les rfrences au sein dune mme classe. Visible pour des rfrences au sein dune mme classe et de classes drives. Visible pour des rfrences en tous lieux. Spcifie quune proprit appartient la classe et non pas aux occurrences de la classe. Nom despace de noms dfini par lutilisateur.
Attributs despace de noms pour le contrle daccs

ActionScript 3.0 comporte quatre attributs spciaux qui contrlent laccs aux proprits dfinies au sein dune classe : public, private, protected et internal. Avec lattribut public, une proprit est visible de nimporte quel point du script. Par exemple, si vous souhaitez quune mthode soit disponible pour du code externe au package, vous devez la dclarer avec lattribut public. Ceci est valable pour toute proprit, quelle soit dclare laide des mots-cls var, const ou function. Avec lattribut private, une proprit nest visible qu partir de la classe o cette proprit est dfinie. Ce comportement est diffrent de celui de lattribut priv en ActionScript 2.0, o une sous-classe pouvait accder une proprit dclare private dune superclasse. Laccs en cours dexcution constitue aussi un changement radical de comportement. En ActionScript 2.0, la restriction daccs introduite par le mot-cl private ne portait que sur la compilation et il tait facile de la contourner lors de lexcution. Cette situation nexiste plus en ActionScript 3.0. Les proprits dsignes comme private sont indisponibles, aussi bien au cours de la compilation que de lexcution. Par exemple, le code ci-dessous cre une classe simple appele PrivateExample pourvue dune variable prive. Elle tente ensuite daccder cette variable depuis un emplacement hors de la classe.
class PrivateExample { private var privVar:String = "private variable"; } var myExample:PrivateExample = new PrivateExample(); trace(myExample.privVar);// compile-time error in strict mode trace(myExample["privVar"]); // ActionScript 2.0 allows access, but in ActionScript 3.0, this is a run-time error.
En ActionScript 3.0, toute tentative daccder une proprit private laide de loprateur point (myExample.privVar) dclenche une erreur de compilation en mode strict. Autrement, lerreur est signale lexcution, tout comme lors de lutilisation de loprateur daccs la proprit (myExample["privVar"]). Le tableau suivant prsente les divers rsultats dune tentative daccs une proprit dclare comme prive qui appartient une classe scelle (non dynamique) :

94
Mode strict oprateur point (.) oprateur crochet ([]) erreur la compilation erreur lexcution
Mode standard erreur lexcution erreur lexcution
Dans les classes dclares avec un attribut dynamic, les tentatives daccs une variable prive ne provoquent pas derreur dexcution. La variable nest simplement pas visible, de sorte que la valeur undefined est renvoye. Une erreur la compilation survient nanmoins si vous utilisez loprateur point en mode strict. Lexemple suivant est identique au prcdent si ce nest que la classe PrivateExample est dclare en tant que classe dynamique :
dynamic class PrivateExample { private var privVar:String = "private variable"; } var myExample:PrivateExample = new PrivateExample(); trace(myExample.privVar);// compile-time error in strict mode trace(myExample["privVar"]); // output: undefined
Les classes dynamiques renvoient le plus souvent la valeur undefined plutt que de gnrer une erreur lorsque du code, extrieur une classe, tente daccder une classe dclare comme proprit prive. Le tableau suivant montre quune erreur est gnre uniquement lorsque loprateur point est utilis pour accder une proprit prive en mode strict :
Mode strict oprateur point (.) oprateur crochet ([]) erreur la compilation
undefined
Mode standard
undefined undefined
Avec lattribut protected, nouveau en ActionScript 3.0, une proprit nest visible qu partir de sa propre classe ou dune sous-classe de celle-ci. Autrement dit, une proprit dclare protected nest disponible qu partir de sa propre classe ou des classes qui lui sont infrieures dans sa hirarchie dhritage, que la sous-classe se trouve dans le mme package ou dans un autre. Pour les programmeurs qui connaissent ActionScript 2.0, cette fonctionnalit est semblable lattribut private de ce langage. Lattribut protected dActionScript 3.0 est galement semblable lattribut protected de Java, la diffrence prs que la version de Java autorise galement laccs partir dun mme package. Lattribut protected est utile pour crer une variable ou une mthode ncessaire aux sous-classes, mais qui ne doit pas tre visible partir du code extrieur la hirarchie dhritage. Avec lattribut interne qui apparat avec ActionScript 3.0, une proprit nest visible qu partir de son propre package. Il sagit de lattribut par dfaut pour du code dans un package et il sapplique toute proprit dpourvue de lun quelconque des attributs suivants :
public private protected
un espace de noms dfini par lutilisateur

Lattribut internal est semblable au contrle daccs par dfaut de Java quoiquen Java il nexiste pas de nom explicite pour ce niveau daccs ; il ne peut tre obtenu que par lomission de tout autre modificateur daccs. Avec lattribut internal, qui apparat avec ActionScript 3.0, il est possible dindiquer explicitement votre intention de ne rendre une proprit visible qu partir de son propre package.

95
Attribut static
Lattribut static, qui peut tre utilis avec des proprits dclares laide des mots-cls var, const ou function, vous permet dassocier une proprit la classe elle-mme plutt qu ses occurrences. Le code externe cette classe doit appeler les proprits statiques laide du nom de la classe et non pas partir du nom dune occurrence. Les sous-classes nhritent pas des proprits statiques ; ces dernires font partie de leur chane de porte. En dautres termes, dans le corps dune sous-classe, une variable ou une mthode statique peut tre utilise sans faire rfrence la classe dans laquelle elle a t dfinie.
Attributs despace de noms dfinis par lutilisateur

Comme solution de rechange aux attributs de contrle daccs prdfinis, vous pouvez crer un espace de noms personnalis pour lutiliser comme attribut. Il ne peut exister quun seul attribut despace de noms par dfinition et vous ne pouvez pas associer cet attribut tout attribut de contrle daccs (public, private, protected, internal).
Variables
Pour dclarer une variable, utilisez les mots-cls var ou const. Les variables dclares avec le mot-cl var sont susceptibles de changer de valeur plusieurs fois au cours de lexcution dun script. Les variables dclares laide du mot-cl const sont appeles des constantes et on ne peut leur attribuer une valeur quune seule fois. Une erreur survient lors dune tentative dattribution dune nouvelle valeur une constante initialise. Variables statiques Les variables statiques sont dclares laide de lassociation du mot-cl static et de linstruction var ou const. Les variables statiques sont affectes une classe, plutt qu une occurrence de classe. Elles permettent de stocker et de partager des informations propres une classe entire dobjets. Par exemple, une variable statique permet denregistrer le nombre de fois o une classe a t instancie ou bien le nombre maximal doccurrences autorises pour une classe. Lexemple ci-dessous cre une variable totalCount qui permet denregistrer le nombre total dinstanciations dune classe et une constante MAX_NUM dont la valeur est le nombre maximum dinstanciations autorises. Les variables totalCount et MAX_NUM sont statiques car elles contiennent des valeurs qui sappliquent la classe elle-mme, plutt qu une occurrence particulire.
class StaticVars { public static var totalCount:int = 0; public static const MAX_NUM:uint = 16; }
Un code extrieur la classe StaticVars, ainsi que toutes ses sous-classes, ne peuvent faire rfrence aux proprits totalCount et MAX_NUM que par le biais de la classe elle-mme. Par exemple, le code suivant fonctionne :
trace(StaticVars.totalCount); // output: 0 trace(StaticVars.MAX_NUM); // output: 16
Comme il est impossible daccder des variables statiques par une occurrence de la classe, le code suivant renvoie des erreurs :
var myStaticVars:StaticVars = new StaticVars(); trace(myStaticVars.totalCount); // error trace(myStaticVars.MAX_NUM); // error

96
Les variables qui sont dclares avec les deux mots-cls static et const doivent tre initialises en mme temps lors de la dclaration de la constante, tout comme la classe StaticVars le fait pour MAX_NUM. Il est impossible dattribuer une valeur MAX_NUM au sein du constructeur ou dune mthode doccurrence. Le code suivant gnre une erreur, car ce nest pas une faon valide dinitialiser une constante statique :
// !! Error to initialize static constant this way class StaticVars2 { public static const UNIQUESORT:uint; function initializeStatic():void { UNIQUESORT = 16; } }
Variables doccurrence Les variables doccurrence contiennent des proprits dclares laide des mots-cls var et const, mais sans le motcl static. Les variables doccurrence, qui sont associes des occurrences de classe plutt qu la classe elle-mme, sont utiles pour conserver des valeurs spcifiques une occurrence. Par exemple, la classe Array dispose dune proprit doccurrence appele length qui conserve le nombre dlments du tableau appartenant une occurrence particulire de la classe Array. Quelles soient dclares avec le mot-cl var ou const, les variables doccurrence ne peuvent pas tre redfinies dans une sous-classe. Il est toutefois possible dobtenir un effet similaire la redfinition de variables, en redfinissant des mthodes de lecture et de dfinition.
Mthodes
Les mthodes sont des fonctions associes la dfinition dune classe. Ds la cration dune occurrence de la classe, une mthode est lie cette occurrence. Contrairement une fonction dclare hors dune classe, une mthode ne peut pas tre utilise sparment de loccurrence laquelle elle est associe. Les mthodes sont dfinies laide du mot-cl function. Comme toute proprit de classe, vous pouvez appliquer nimporte quel attribut de proprit de classe aux mthodes, quelles soient prives, protges, publiques, internes ou statiques, ainsi qu un espace de noms personnalis. Vous pouvez utiliser une instruction function telle que :
public function sampleFunction():String {}
Vous pouvez aussi utiliser une variable laquelle vous attribuez une expression de fonction, comme ci-dessous :
public var sampleFunction:Function = function () {}
Dans la plupart des cas, il est prfrable dutiliser une instruction function plutt quune expression de fonction pour les raisons suivantes :
Les instructions function sont plus concises et plus faciles lire. Elles vous permettent dutiliser les mots-cls override et final. Les instructions function crent une liaison plus robuste entre lidentifiant (le nom de la fonction) et le code dans
le corps de la mthode. Comme la valeur dune variable peut tre modifie par une instruction assignment, le lien entre une variable et son expression de fonction peut tre rompu tout moment. Bien quil soit possible de rsoudre ce problme en dclarant la variable avec const au lieu de var, cette technique nest pas recommande car elle rend le code difficilement lisible et empche dutiliser les mots-cls override et final. Il existe toutefois un cas dans lequel une expression de fonction doit tre utilise : si vous choisissez daffecter une fonction lobjet prototype.

97
Mthodes constructeur
Les mthodes constructeur, parfois appeles simplement constructeurs, sont des fonctions qui portent le nom de la classe dans laquelle elles sont dfinies. Tout code qui figure dans une mthode constructeur est excut toutes les fois quune occurrence de la classe est cre laide du mot-cl new. Par exemple, le code suivant dfinit une classe simple appele Example qui contient une proprit unique appele status. La valeur initiale de la variable status est fixe dans la fonction constructeur.
class Example { public var status:String; public function Example() { status = "initialized"; } } var myExample:Example = new Example(); trace(myExample.status); // output: initialized
Les mthodes constructeur ne peuvent tre que publiques, mais lutilisation de lattribut public est facultative. Il est impossible dutiliser lun des autres spcificateurs de contrle daccs, y compris private, protected ou internal avec un constructeur. De mme quil est impossible dutiliser non plus, avec un constructeur, un espace de noms dfini par lutilisateur. Un constructeur peut appeler explicitement le constructeur de sa superclasse directe, laide de linstruction super(). Si le constructeur de la superclasse nest pas explicitement appel, le compilateur insre automatiquement un appel devant la premire instruction dans le corps du constructeur. Vous pouvez aussi appeler des mthodes de la superclasse laide du prfixe super en rfrence la superclasse. Si vous dcidez dutiliser la fois super() et super dans le corps du mme constructeur, veillez appeler super() en premier. Sinon, la rfrence super na pas le comportement prvu. Le constructeur super() devrait galement tre appel avant toute instruction throw ou return. Lexemple suivant dcrit ce qui se passe si vous tentez dutiliser la rfrence super avant dappeler le constructeur super(). Une nouvelle classe, ExampleEx, tend la classe Example. Le constructeur ExampleEx tente daccder la variable dtat dfinie dans sa super classe, mais avant un appel super(). Linstruction trace() du constructeur ExampleEx produit la valeur null car la variable status nest pas disponible tant que le constructeur super() na pas t excut.
class ExampleEx extends Example { public function ExampleEx() { trace(super.status); super(); } } var mySample:ExampleEx = new ExampleEx(); // output: null
Bien que lutilisation de linstruction return au sein dun constructeur soit autorise, il nest pas permis de renvoyer une valeur. En dautres termes, aucune expression ou valeur ne peut tre associe linstruction return. Par consquent, les mthodes constructeur ne sont pas autorises renvoyer des valeurs, ce qui signifie quaucun type de valeur renvoye ne peut tre spcifi.

98
Si vous ne dfinissez pas de mthode constructeur dans la classe, le compilateur cre automatiquement un constructeur vide. Si la classe en tend une autre, le compilateur insre un appel super() dans le constructeur quil gnre.
Mthodes statiques
Les mthodes statiques, galement appeles parfois mthodes de classe, sont dclares avec le mot-cl static. Les mthodes statiques sont affectes une classe plutt qu une occurrence de classe. Elles permettent dencapsuler des fonctionnalits qui ont une porte plus tendue que ltat dune occurrence individuelle. Comme les mthodes statiques sont associes lintgralit dune classe, on peut accder des mthodes statiques uniquement par une classe et pas du tout par une occurrence de classe. Les mthodes statiques permettent dencapsuler des fonctionnalits qui ne se bornent pas la modification dtat des occurrences de classe. Autrement dit, une mthode devrait tre statique si elle offre des fonctionnalits qui naffectent pas directement la valeur dune occurrence de classe. Par exemple, la classe Date possde une mthode statique appele parse() qui reoit une chane et la convertit en nombre. La mthode est statique parce quelle naffecte pas une occurrence individuelle de sa classe. La mthode parse(), reoit une chane reprsentant une valeur de date, lanalyse et renvoie un nombre dans un format compatible avec la reprsentation interne dun objet Date. Cette mthode nest pas une mthode doccurrence, puisquil ny aurait aucun intrt lappliquer une occurrence de la classe Date. Comparons la mthode statique parse() lune des mthodes doccurrence de la classe Date, comme getMonth(). La mthode getMonth() est une mthode doccurrence parce quelle agit directement sur la valeur dune occurrence en rcuprant un composant spcifique, le mois, dune occurrence de Date. Comme les mthodes statiques ne sont pas lies des occurrences individuelles, vous ne pouvez pas utiliser les motscls this ou super dans le corps dune mthode statique. Les deux rfrences this et super nont de sens que dans le contexte dune mthode doccurrence. Contrairement dautres langages de programmation bass sur des classes, les mthodes statiques en ActionScript 3.0 ne sont pas hrites.
Mthodes doccurrence
Les mthodes doccurrence sont dclares sans le mot-cl static. Les mthodes doccurrence, qui sont affectes aux occurrences dune classe et non pas la classe elle-mme, permettent dimplmenter des fonctionnalits qui affectent des occurrences individuelles dune classe. Par exemple, la classe Array contient une mthode doccurrence appele sort() qui opre directement sur des occurrences Array. Dans le corps dune mthode doccurrence, les variables statiques et doccurrence sont de mme porte ; ce qui signifie que les variables dfinies dans la mme classe peuvent tre rfrences laide dun identificateur simple. Par exemple, la classe suivante, CustomArray, tend la classe Array. La classe CustomArray dfinit une variable statique appele arrayCountTotal destine contenir le nombre total doccurrences de la classe, une variable doccurrence appele arrayNumber qui enregistre lordre dans lequel les occurrences ont t cres et une mthode doccurrence appele getPosition() qui renvoie les valeurs de ces variables.

99
public class CustomArray extends Array { public static var arrayCountTotal:int = 0; public var arrayNumber:int; public function CustomArray() { arrayNumber = ++arrayCountTotal; } public function getArrayPosition():String { return ("Array " + arrayNumber + " of " + arrayCountTotal); } }
Pour accder la variable statique arrayCountTotal, du code externe cette classe doit passer par lobjet class utilisant CustomArray.arrayCountTotal ; mais le code qui rside dans le corps de la mthode getPosition() peut faire rfrence directement la variable statique arrayCountTotal. Cest galement le cas pour les variables statiques dans les superclasses. Bien que les proprits statiques ne soient pas hrites en ActionScript 3.0, les proprits statiques des superclasses sont dans la porte. Par exemple, la classe Array possde quelques variables statiques, dont lune est une constante appele DESCENDING. Le code qui rside dans une sous-classe dArray peut accder la constante statique DESCENDING laide dun identifiant simple :
public class CustomArray extends Array { public function testStatic():void { trace(DESCENDING); // output: 2 } }
La valeur de la rfrence this dans le corps dune mthode doccurrence est une rfrence loccurrence laquelle la mthode est affecte. Le code suivant montre que la rfrence this pointe sur loccurrence qui contient la mthode :
class ThisTest { function thisValue():ThisTest { return this; } } var myTest:ThisTest = new ThisTest(); trace(myTest.thisValue() == myTest); // output: true
Il est possible de contrler lhritage des mthodes doccurrence laide des mots-cls override et final. Vous pouvez utiliser lattribut override pour redfinir une mthode hrite et lattribut final pour empcher les sousclasses de redfinir une mthode.
Mthodes accesseur get et set

Les fonctions daccesseur de lecture et de dfinition, appeles aussi accesseurs Get et Set, vous permettent de suivre les principes de programmation sur le masquage et lencapsulation des informations tout en offrant une interface de programmation conviviale pour les classes que vous crez. Les fonctions de lecture et de dfinition (get et set) permettent de garder prives les proprits dune classe. Par contre, elles permettent des utilisateurs de votre classe daccder ces proprits comme sils accdaient une variable de classe au lieu dappeler une mthode de classe.

100
Lavantage de cette approche est quelle permet dviter les fonctions daccesseur traditionnelles aux noms compliqus, comme getPropertyName() et setPropertyName(). Leur autre avantage est quelles vitent davoir deux fonctions exposes publiquement pour chaque proprit accessible en lecture et en criture. Dans lexemple suivant, la classe appele GetSet, possde des fonctions accesseurs de lecture et de dfinition appeles
publicAccess() qui permettent daccder la variable prive appele privateProperty : class GetSet { private var privateProperty:String; public function get publicAccess():String { return privateProperty; } public function set publicAccess(setValue:String):void { privateProperty = setValue; } }
Si vous tentez daccder directement la proprit privateProperty, une erreur se produit :

var myGetSet:GetSet = new GetSet(); trace(myGetSet.privateProperty); // error occurs
En revanche, si vous utilisez la classe GetSet, vous faites appel ce qui parat tre une proprit appele publicAccess, mais qui correspond, en fait, une paire de fonctions accesseurs de lecture et de dfinition intervenant sur la proprit prive appele privateProperty. Lexemple suivant instancie la classe GetSet, puis dfinit la valeur de la proprit privateProperty laide de laccesseur public appel publicAccess :
var myGetSet:GetSet = new GetSet(); trace(myGetSet.publicAccess); // output: null myGetSet.publicAccess = "hello"; trace(myGetSet.publicAccess); // output: hello
Les fonctions daccesseur Get et Set permettent galement de redfinir des proprits hrites dune superclasse, ce qui nest pas possible avec des variables rgulires membres de classes. Les variables des membres de la classe qui sont dclares laide du mot-cl var ne peuvent pas tre redfinies dans une sous-classe. Toutefois, cette restriction ne concerne pas les proprits cres laide des fonctions daccesseur Get et Set. Vous pouvez utiliser lattribut override sur des fonctions daccesseur Get et Set hrites dune superclasse.
Mthodes lies
Une mthode lie, parfois appele fermeture de mthode, est tout simplement une mthode extraite de son occurrence. On peut citer comme exemples les mthodes passes en arguments une fonction ou renvoyes comme valeurs par une fonction. La mthode lie, qui est une nouveaut dActionScript 3.0, est semblable une fermeture de fonction dans la mesure o elle conserve son environnement lexical, mme aprs avoir t extraite de son occurrence. Toutefois, la diffrence entre une mthode lie et une fermeture de fonction rside dans le fait que la rfrence this dune mthode lie reste lie loccurrence qui implmente cette mthode. Autrement dit, la rfrence this dune mthode lie pointe toujours sur lobjet original qui a implment la mthode. Pour les fermetures de fonction, la rfrence this est gnrique, ce qui signifie quelle pointe sur lobjet auquel est associe la fonction lorsquelle est appele.

101
Il est important de comprendre les mthodes lies pour utiliser le mot-cl this bon escient. Noubliez pas que this reprsente une rfrence lobjet parent dune mthode. La plupart des programmeurs en ActionScript sattendent ce que le mot-cl this reprsente toujours lobjet ou la classe qui contient la dfinition dune mthode. Ce nest pas toujours le cas sans mthode lie. Par exemple, dans les versions prcdentes dActionScript, la rfrence this ne pointait pas toujours sur loccurrence qui implmentait la mthode. En ActionScript 2.0, lorsque les mthodes sont extraites dune occurrence, non seulement la rfrence this nest pas lie loccurrence originale, mais les variables et les mthodes de la classe de cette occurrence ne sont pas disponibles. Toutefois, ce problme nexiste plus avec ActionScript 3.0, car les mthodes lies sont automatiquement cres lorsque la mthode est passe en paramtre. Avec les mthodes lies, le mot-cl this fait toujours rfrence lobjet ou la classe dans laquelle la mthode est dfinie. Le code suivant dfinit une classe appele ThisTest, qui contient une mthode appele foo() dfinissant la mthode lie et une mthode appele bar() qui renvoie cette mthode lie. Le code extrieur la classe cre une occurrence de la classe ThisTest, appelle la mthode bar() et enregistre la valeur renvoyer dans la variable myFunc.
class ThisTest { private var num:Number = 3; function foo():void // bound method defined { trace("foo's this: " + this); trace("num: " + num); } function bar():Function { return foo; // bound method returned } } var myTest:ThisTest = new ThisTest(); var myFunc:Function = myTest.bar(); trace(this); // output: [object global] myFunc(); /* output: foo's this: [object ThisTest] output: num: 3 */
Les deux dernires lignes de code montrent que la rfrence this dans la mthode lie foo() pointe encore sur une occurrence de la classe ThisTest, bien que la rfrence this de la ligne prcdente pointe sur lobjet global. De plus, la mthode lie, stocke dans la variable myFunc, peut encore accder aux variables membres de la classe ThisTest. Si ce code est excut en ActionScript 2.0, les rfrences this seront identiques et la variable num sera undefined. Les gestionnaires dvnement constituent un domaine dans lequel lajout des mthodes lies est le plus notable, car la mthode addEventListener() ncessite de transmettre une fonction ou une mthode en argument.
Enumrations et classes
Les numrations sont des types de donnes que vous pouvez crer pour encapsuler un petit ensemble de valeur. Contrairement C++ avec le mot-cl enum et Java avec linterface dnumration, ActionScript 3.0 ne dispose pas dun mcanisme dnumration spcifique. Il est toutefois possible de crer des numrations laide de classes et de constantes statiques. Par exemple, en ActionScript 3.0, la classe PrintJob utilise une numration appele PrintJobOrientation pour stocker les valeurs "landscape" et "portrait", comme lindique le code ci-dessous :

102
public final class PrintJobOrientation { public static const LANDSCAPE:String = "landscape"; public static const PORTRAIT:String = "portrait"; }
Par convention, une classe dnumration est dclare avec lattribut final, car il nest pas ncessaire dtendre cette classe. Cette classe tant compose uniquement de membres statiques, il est impossible den crer des occurrences. En effet, on accde aux valeurs de lnumration directement par lobjet classe, comme le montre lextrait de code suivant :
var pj:PrintJob = new PrintJob(); if(pj.start()) { if (pj.orientation == PrintJobOrientation.PORTRAIT) { ... } ... }
Toutes les classes dnumration dActionScript 3.0 contiennent uniquement des variables de type String, int ou uint. Le fait que les fautes de frappe sont plus faciles dtecter avec les numrations prsente un grand avantage par rapport des chanes littrales ou des nombres. Si vous faites une erreur dans le nom dune numration, le compilateur ActionScript gnre une erreur. Si vous utilisez des valeurs littrales, le compilateur acceptera un nom mal pel ou un chiffre erron. Dans lexemple ci-dessus, le compilateur gnre une erreur si le nom de la constante dnumration est incorrect, comme dans lextrait suivant :
if (pj.orientation == PrintJobOrientation.PORTRAI) // compiler error
Toutefois, le compilateur ne gnre pas derreur si vous faites une faute de frappe dans le nom dune chane littrale :
if (pj.orientation == "portrai") // no compiler error
Une autre technique de cration dnumrations consiste crer une classe spare avec des proprits statiques pour lnumration. Toutefois, cette technique est diffrente dans la mesure o chacune des proprits statiques contient une occurrence de la classe plutt quune valeur chane ou un entier. Par exemple, le code suivant cre une classe dnumration pour les jours de la semaine :
public final class Day { public static const public static const public static const public static const public static const public static const public static const }
MONDAY:Day = new Day(); TUESDAY:Day = new Day(); WEDNESDAY:Day = new Day(); THURSDAY:Day = new Day(); FRIDAY:Day = new Day(); SATURDAY:Day = new Day(); SUNDAY:Day = new Day();
Cette technique nest pas utilise par ActionScript 3.0, mais de nombreux dveloppeurs y ont recours car elle permet dobtenir un meilleur type de vrification. Par exemple, une mthode qui renvoie une valeur dnumration peut restreindre la valeur renvoye au type de donnes de lnumration. Le code suivant illustre non seulement une fonction qui renvoie un jour de la semaine, mais aussi un appel de fonction qui utilise le type numration comme annotation de type :

103
function getDay():Day { var date:Date = new Date(); var retDay:Day; switch (date.day) { case 0: retDay = Day.MONDAY; break; case 1: retDay = Day.TUESDAY; break; case 2: retDay = Day.WEDNESDAY; break; case 3: retDay = Day.THURSDAY; break; case 4: retDay = Day.FRIDAY; break; case 5: retDay = Day.SATURDAY; break; case 6: retDay = Day.SUNDAY; break; } return retDay; } var dayOfWeek:Day = getDay();
Il est galement possible damliorer la classe Day afin quelle associe un entier chaque jour de la semaine et comporte une mthode toString() renvoyant une reprsentation du jour sous forme de chane.
Classes des lments incorpors

ActionScript 3.0 utilise des classes spciales, appeles classes des lments incorpors, pour reprsenter les actifs incorpors. Un lment incorpor est un lment (son, image ou police) qui est incorpor au fichier SWF lors de la compilation. Contrairement au chargement dynamique, lincorporation des actifs les rend disponibles immdiatement lors de lexcution ; mais cette mthode augmente la taille des fichiers SWF.
Utilisation de classes dactifs incorpors dans Flash Professional

Pour incorporer un lment, placez-le dabord dans la bibliothque dun fichier FLA. Utilisez ensuite la proprit de liaison de llment pour fournir un nom la classe de llment incorpor. Sil nexiste pas de classe de ce nom dans le chemin de classe indiqu, une classe est automatiquement cre. Vous pouvez alors crer une occurrence de la classe dlments incorpors et utiliser les proprits et mthodes dfinies ou hrites par cette classe. Par exemple, le code suivant permet de lire un son intgr et li une classe dlments incorpors appele PianoMusic :
var piano:PianoMusic = new PianoMusic(); var sndChannel:SoundChannel = piano.play();

104
Pour incorporer des actifs dans un projet Flash Professional, vous pouvez aussi utiliser la balise de mtadonnes [Embed] (voir ci-aprs). Dans ce cas, Flash Professional fait appel au compilateur Flex, et non son propre compilateur, pour compiler le projet.
Utilisation de classe dactifs intgrs laide du compilateur Flex

Lorsque vous utilisez le compilateur Flex, servez-vous de la balise de mtadonnes [Embed] pour incorporer un actif dans le code ActionScript. Placez lactif dans le dossier source principal ou dans un autre dossier qui se trouve dans le chemin de cration. Lorsque le compilateur Flex trouve une balise de mtadonnes Embed, il cre la classe dactifs intgrs pour vous. Il est possible daccder la classe par une variable de type de donnes Class que lon dclare immdiatement aprs la balise de mtadonnes [Embed]. Par exemple, le code ci-dessous intgre un son appel sound1.mp3. Il utilise une variable appele soundCls pour enregistrer une rfrence la classe de llment intgr associ ce son. Lexemple cre alors une occurrence de la classe de llment intgr et appelle la mthode play() sur cette occurrence :
package { import flash.display.Sprite; import flash.media.SoundChannel; import mx.core.SoundAsset; public class SoundAssetExample extends Sprite { [Embed(source="sound1.mp3")] public var soundCls:Class; public function SoundAssetExample() { var mySound:SoundAsset = new soundCls() as SoundAsset; var sndChannel:SoundChannel = mySound.play(); } } }
Adobe Flash Builder Pour utiliser la balise de mtadonnes [Embed] dans un projet ActionScript Flash Builder, importez les classes ncessaires depuis la structure Flex. Par exemple, pour incorporer des sons, importez la classe mx.core.SoundAsset. Pour utiliser la structure Flex, ajoutez le fichier framework.swc votre chemin de cration ActionScript. La taille du fichier SWF va alors augmenter.
Adobe Flex Dans Flex, vous pouvez aussi intgrer un actif laide de la directive @Embed() dans une dfinition de balise MXML.

105
Interfaces
Une interface est une collection de dclarations de mthodes qui autorise les communications entre des objets diffrents. Par exemple, ActionScript 3.0 dfinit linterface IEventDispatcher qui contient les dclarations des mthodes quune classe peut utiliser pour grer les objets vnements. Linterface IEventDispatcher tablit une technique standard permettant aux objets de schanger les vnements. Le code suivant reprsente la dfinition de linterface IEventDispatcher :
public interface IEventDispatcher { function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean = false):void; function removeEventListener(type:String, listener:Function, useCapture:Boolean=false):void; function dispatchEvent(event:Event):Boolean; function hasEventListener(type:String):Boolean; function willTrigger(type:String):Boolean; }
Les interfaces sont bases sur la distinction entre linterface dune mthode et limplmentation de celle-ci. Linterface dune mthode comprend toutes les informations ncessaires pour appeler cette mthode : le nom de la mthode, lensemble des paramtres quelle reoit et le type de donnes quelle renvoie. Limplmentation dune mthode comprend non seulement les informations de linterface, mais aussi les instructions excutables qui caractrisent le comportement de la mthode. La dfinition dune interface ne contient que les interfaces de la mthode et toute classe qui implmente linterface doit donc dfinir les implmentations de la mthode. Dans ActionScript 3.0, la classe EventDispatcher implmente linterface IEventDispatcher en dfinissant toutes les mthodes de cette interface et en ajoutant le corps de chacune de ces mthodes. Le code suivant est extrait de la dfinition de la classe EventDispatcher :
public class EventDispatcher implements IEventDispatcher { function dispatchEvent(event:Event):Boolean { /* implementation statements */ } ... }
Linterface IEventDispatcher fait office de protocole utilis par les occurrences dEventDispatcher pour traiter les objets vnements et les transmettre aux autres objets qui ont galement implment cette interface. Il est aussi possible de dcrire une interface en disant quelle dfinit un type de donnes, au mme titre quune classe. En consquence, une interface peut tre utilise comme annotation de type, tout comme une classe. En tant que type de donnes, une interface peut galement tre utilise avec des oprateurs, par exemple les oprateurs is et as, qui ncessitent un type de donnes. Toutefois, linverse dune classe, il nest pas possible dinstancier une interface. Cest en raison de cette distinction que de nombreux programmeurs voient les interfaces comme des types de donnes abstraites et les classes comme des types de donnes concrtes.

106
Dfinition dune interface

La structure de la dfinition dune interface est similaire celle de la dfinition dune classe, ceci prs quune interface ne peut pas contenir les corps des mthodes. Les interfaces ne peuvent pas comporter des variables ou des constantes, mais elles peuvent contenir des mthodes de lecture et de dfinition. Pour dfinir une interface, on utilise le mot-cl interface. Par exemple, linterface suivante, IExternalizable, fait partie du package flash.utils dActionScript 3.0. Linterface IExternalizable dfinit un protocole pour srialiser un objet, ce qui correspond la conversion dun objet en un format qui convienne au stockage sur un priphrique ou au transport sur un rseau.
public interface IExternalizable { function writeExternal(output:IDataOutput):void; function readExternal(input:IDataInput):void; }
Linterface IExternalizable est dclare avec le modificateur de contrle daccs public. Les dfinitions dinterfaces peuvent uniquement tre modifies laide des spcificateurs de contrle daccs public et internal. Dans une dfinition dinterface, les dclarations de mthodes ne peuvent pas comporter de spcificateur de contrle daccs. ActionScript 3.0 respecte la convention de nom selon laquelle les noms des interfaces dbutent par un I majuscule, mais vous pouvez utiliser tout identificateur autoris comme nom dinterface. Les dfinitions dinterfaces sont souvent places au niveau suprieur dun package. Les dfinitions dinterfaces ne peuvent pas tre places dans une dfinition de classe ou dans une autre dfinition dinterface. Une interface peut tendre une ou plusieurs autres interfaces. Par exemple, linterface IExample tend linterface IExternalizable :
public interface IExample extends IExternalizable { function extra():void; }
Toute classe qui implmente linterface IExample doit comporter non seulement les implmentations de la mthode extra(), mais aussi celles des mthodes writeExternal() et readExternal() hrites de linterface IExternalizable.
Implmentation dune interface dans une classe

La classe est le seul lment du langage ActionScript 3.0 qui puisse implmenter une interface. Pour implmenter une ou plusieurs interfaces, on utilise le mot-cl implements dans une dclaration de classe. Lexemple suivant dfinit deux interfaces, IAlpha et IBeta, ainsi quune classe, Alpha, qui les implmente toutes deux :
interface IAlpha { function foo(str:String):String; } interface IBeta { function bar():void; } class Alpha implements IAlpha, IBeta { public function foo(param:String):String {} public function bar():void {} }

107
Dans une classe qui implmente une interface, les mthodes implmentes doivent :
Utiliser lidentificateur de contrle daccs public. Utiliser le mme nom que la mthode de linterface. Avoir le mme nombre de paramtres, chacun deux tant du type de donnes correspondant celui du paramtre
quivalent dans la mthode de linterface.
Utiliser le mme type de retour.

public function foo(param:String):String {}
Vous disposez toutefois dune certaines souplesse pour le nom des paramtres des mthodes que vous implmentez. Bien que le nombre et le type de donnes des paramtres de la mthode implmente doivent correspondre ceux de la mthode de linterface, il nest pas obligatoire que les noms des paramtres soient identiques. Par exemple, dans lexemple ci-dessus, le paramtre de la mthode Alpha.foo() est appel param. Par contre, le paramtre correspondant est appel str dans la mthode de linterface IAlpha.foo() :
function foo(str:String):String;
Les valeurs par dfaut des paramtres offrent galement une certaine souplesse. La dfinition dune interface peut comporter des dclarations de fonctions avec des valeurs par dfaut pour les paramtres. Une mthode qui implmente lune de ces dclarations de fonction doit disposer dune valeur par dfaut pour le ou les paramtres. Cette valeur doit tre du mme type de donnes que celle qui est spcifie dans la dfinition de linterface, mais ce nest pas forcment le cas pour la valeur relle. Par exemple, le code ci-dessous dfinit une interface contenant une mthode dont le paramtre a la valeur 3 par dfaut :
interface IGamma { function doSomething(param:int = 3):void; }
La dfinition de classe suivante implmente linterface Igamma, mais utilise une autre valeur par dfaut pour le paramtre :
class Gamma implements IGamma { public function doSomething(param:int = 4):void {} }
Cette souplesse est due au fait que les rgles dimplmentation dune interface sont spcifiquement conues afin dassurer une compatibilit des types de donnes ; il nest pas ncessaire, pour ce faire, dexiger des noms et des valeurs par dfaut identiques pour les paramtres.
Hritage
Lhritage est une forme de rutilisation du code qui permet aux programmeurs de dvelopper de nouvelles classes partir de classes existantes. Les classes existantes sont alors frquemment appeles classes de base ou superclasses, alors que les nouvelles classes sont gnralement appeles sous-classes. Lun des principaux avantages de lhritage est quil permet de rutiliser le code dune classe de base sans modifier le code existant. De plus, lhritage ne ncessite pas de modifier les modes dinteraction des autres classes avec la classe de base. Plutt que de modifier une classe existante, qui est peut-tre soigneusement teste et dj utilise, lhritage permet de traiter cette classe comme un module intgr qui peut tre tendu laide de proprits et de mthodes supplmentaires. Cest pourquoi on utilise le mot-cl extends pour indiquer quune classe hrite dune autre classe.

108
Lhritage permet galement de tirer parti du polymorphisme du code. Le polymorphisme est la possibilit dutiliser un nom de mthode unique pour une mthode qui se comporte diffremment en fonction des types de donnes quelle reoit. Par exemple, supposons une classe de base appele Shape, avec deux sous-classes appeles Circle et Square. La classe Shape dfinit une mthode appele area() qui renvoie la surface de Shape. Si vous avez implment le polymorphisme, vous pouvez appeler la mthode area() pour les objets de type Circle ou Square et lui faire excuter le calcul correct. Lhritage autorise le polymorphisme en permettant aux sous-classes dhriter et de dfinir, ou override, les mthodes de la classe de base. Dans lexemple suivant, la mthode area() est redfinie par les classes Circle et Square :
class Shape { public function area():Number { return NaN; } } class Circle extends Shape { private var radius:Number = 1; override public function area():Number { return (Math.PI * (radius * radius)); } } class Square extends Shape { private var side:Number = 1; override public function area():Number { return (side * side); } } var cir:Circle = new Circle(); trace(cir.area()); // output: 3.141592653589793 var sq:Square = new Square(); trace(sq.area()); // output: 1
Dans la mesure o chaque classe dfinit un type de donnes, lutilisation de lhritage cre un rapport spcial entre une classe de base et une classe qui ltend. Une sous-classe possde obligatoirement toutes les proprits de sa classe de base, ce qui signifie quil est toujours possible de substituer une occurrence dune sous-classe une occurrence de la classe de base. Par exemple, si une mthode dfinit un paramtre du type Shape, il est parfaitement valable de lui transmettre un argument du type Circle, car Circle tend Shape, comme on peut le voir ci-dessous :
function draw(shapeToDraw:Shape) {} var myCircle:Circle = new Circle(); draw(myCircle);

109
Proprits et hritage des occurrences

Quelle soit dfinie laide du mot-cl function, var ou const, une proprit doccurrence est hrite par toutes les sous-classes tant que cette proprit nest pas dclare avec lattribut private dans la classe de base. Par exemple, la classe Event dActionScript 3.0 possde des sous-classes nombreuses qui hritent de proprits communes tous les objets vnements. Pour certains types dvnements, la classe Event contient toutes les proprits ncessaires pour dfinir lvnement. Ces types dvnements ne ncessitent pas de proprits doccurrence au-del de celles qui sont dfinies dans la classe Event. Lvnement complete, qui est dclench lorsque des donnes ont t charges avec succs, et lvnement connect, qui se produit lorsquune connexion rseau a t tablie, sont des exemples de ce type dvnement. Lexemple suivant est extrait de la classe Event. Il montre certaines proprits et mthodes dont les sous-classes hritent. Comme elles sont hrites, ces proprits sont accessibles par une occurrence de nimporte quelle sous-classe.
public class Event { public function get type():String; public function get bubbles():Boolean; ... public public public public ... } function function function function stopPropagation():void {} stopImmediatePropagation():void {} preventDefault():void {} isDefaultPrevented():Boolean {}
Dautres types dvnements ncessitent des proprits uniques qui ne sont pas disponibles dans la classe Event. Ces vnements sont dfinis laide de sous-classes de la classe Event, ce qui permet dajouter de nouvelles proprits celles de cette classe Event. La classe MouseEvent est un exemple de sous-classe de ce type. Elle ajoute des proprits uniques aux vnements associs un mouvement ou un clic de souris, tels que les vnements mouseMove et click. Lexemple suivant est extrait de la classe MouseEvent. Il montre la dfinition des proprits inhrentes la sous-classe parce quabsentes de la classe de base.
public class MouseEvent extends Event { public static const CLICK:String= "click"; public static const MOUSE_MOVE:String = "mouseMove"; ... public function get stageX():Number {} public function get stageY():Number {} ... }
Spcificateurs de contrle daccs et hritage Si une proprit est dclare avec le mot-cl public, elle est visible de nimporte quel point du code. Cela signifie que le mot-cl public nintroduit aucune restriction sur lhritage des proprits, contrairement aux mots-cls private, protected et internal. Si une proprit est dclare avec le mot-cl private, elle nest visible qu partir de la classe qui la dfinit. Autrement dit les sous-classes nen hritent pas. Ce comportement est diffrent de celui des versions antrieures dActionScript o le mot-cl private se comportait plutt comme le mot-cl protected dActionScript 3.0.

110
Le mot-cl protected indique quune proprit est visible non seulement partir de la classe qui la dfinit, mais aussi partir de toutes les sous-classes de celle-ci. Contrairement au mot-cl protected en Java, en ActionScript 3.0 le motclprotected ne rend pas une proprit visible partir de toutes les autres classes du mme package. En ActionScript 3.0, seules les sous-classes peuvent accder une proprit dclare avec le mot-cl protected. De plus, une proprit protge est visible partir dune sous-classe mme si celle-ci ne se trouve pas dans le mme package que sa classe de base. Pour limiter la visibilit dune proprit au package dans lequel elle est dfinie, vous pouvez soit utiliser le mot-cl
internal, soit nutiliser aucun spcificateur de contrle daccs. Le spcificateur de contrle daccs internal est
appliqu par dfaut si vous nen indiquez aucun. Seule une sous-classe rsidant dans le mme package pourra hriter dune proprit marque comme internal. Seule une sous-classe rsidant dans le mme package peut hriter dune proprit dsigne comme internal. Lexemple suivant montre comment chaque spcificateur de contrle daccs affecte lhritage dans et au-del des package. Le code ci-dessous dfinit une classe principale dapplication appele AccessControl et deux autres classes, Base et Extender. La classe Base se trouve dans un package appel foo et la classe Extender, qui est une sous-classe de la classe Base, dans un package appel bar. La classe AccessControl nimporte que la classe Extender et cre une occurrence de celle-ci qui tente daccder une variable appele str, dfinie dans la classe Base. La variable str est dclare comme public, si bien que le code est compil et excut comme lillustre lexemple ci-dessous :
// Base.as in a folder named foo package foo { public class Base { public var str:String = "hello"; // change public on this line } } // Extender.as in a folder named bar package bar { import foo.Base; public class Extender extends Base { public function getString():String { return str; } } } // main application class in file named AccessControl.as package { import flash.display.MovieClip; import bar.Extender; public class AccessControl extends MovieClip { public function AccessControl() { var myExt:Extender = new Extender(); trace(myExt.str);// error if str is not public trace(myExt.getString()); // error if str is private or internal } } }

111
Pour voir leffet des autres spcificateurs de contrle daccs lors de la compilation et de lexcution de cet exemple, changez le spcificateur de contrle de la variable str private, protected ou internal aprs avoir supprim ou mis en commentaire la ligne suivante dans la classe AccessControl :
trace(myExt.str);// error if str is not public
Redfinition des variables impossible Les proprits dclares laide des mots-cls var ou const sont hrites mais ne peuvent pas tre redfinies. Redfinir, ou forcer, une proprit au sens de override signifie redfinir cette proprit dans une sous-classe. Les accesseurs get et set (cest--dire les proprits dclares avec le mot-cl function) constituent le seul type de proprit quil est possible de redfinir. Bien quil soit impossible de redfinir une variable doccurrence, vous pouvez obtenir le mme rsultat par la cration des mthodes de lecture et de dfinition pour cette variable doccurrence et en forant ces mthodes.
Redfinition des mthodes

Redfinir une mthode signifie redfinir le comportement dune mthode hrite. Les mthodes statiques ne sont pas hrites et ne peuvent donc pas tre redfinies. Toutefois, les sous-classes hritent des mthodes doccurrence et il est donc possible de redfinir celles-ci sous rserve de deux conditions :
La mthode doccurrence ne doit pas tre dclare avec le mot-cl final dans la classe de base. Lorsquil est utilis
avec une mthode doccurrence, le mot-cl final indique que le programmeur veut empcher les sous-classes de redfinir cette mthode.
La mthode doccurrence ne doit pas tre dclare avec le contrle daccs private dans la classe de base. Si une
mthode est dsigne comme private dans la classe de base, il est inutile dutiliser le mot-cl override lors de la dfinition dune mthode portant le mme nom dans la sous-classe, puisque la mthode de la classe de base nest pas visible partir de la sous-classe. Pour redfinir une mthode doccurrence correspondant ces critres, la dfinition de la mthode dans la sousclasse doit utiliser le mot-cl override et correspondre, comme dfini ci-dessous, la version de cette mthode dans la superclasse :
La mthode de redfinition doit avoir le mme niveau de contrle daccs que celle de la classe de base. Les
mthodes dfinies comme internes doivent avoir le mme niveau de contrle daccs que celles qui nont pas de spcificateur de contrle daccs.
La mthode de redfinition doit avoir le mme nombre de paramtres que celle de la classe de base. Les paramtres de la mthode de redfinition doivent avoir les mmes annotations de type de donnes que ceux de
la mthode de la classe de base.
La mthode de redfinition doit avoir le mme type de renvoi que celle de la classe de base.
Toutefois, il nest pas ncessaire que les noms des paramtres de la mthode de redfinition correspondent ceux des paramtres de la classe de base, tant quil y a une correspondance entre le nombre de paramtres et leurs types de donnes. Instruction super Il arrive frquemment que les programmeurs souhaitent complter le comportement de la mthode de superclasse quils redfinissent, plutt que de remplacer ce comportement. Il est donc ncessaire de disposer dun mcanisme permettant une mthode dune sous-classe dappeler sa propre superclasse. Ce mcanisme est assur par linstruction super qui contient une rfrence la superclasse immdiate. Lexemple suivant dfinit une classe appele Base, qui contient la mthode appele thanks() et une sous-classe de Base appele Extender, qui redfinit la mthode thanks(). La mthode Extender.thanks() utilise linstruction super pour appeler Base.thanks().

112
package { import flash.display.MovieClip; public class SuperExample extends MovieClip { public function SuperExample() { var myExt:Extender = new Extender() trace(myExt.thanks()); // output: Mahalo nui loa } } } class Base { public function thanks():String { return "Mahalo"; } } class Extender extends Base { override public function thanks():String { return super.thanks() + " nui loa"; } }
Redfinition des accesseurs Get et Set Bien quil soit impossible de redfinir les variables dfinies dans une superclasse, il est possible de redfinir les accesseurs Get et Set. Par exemple, le code suivant redfinit un accesseur Get appel currentLabel qui est dfini dans la classe MovieClip dActionScript 3.0 :
package { import flash.display.MovieClip; public class OverrideExample extends MovieClip { public function OverrideExample() { trace(currentLabel) } override public function get currentLabel():String { var str:String = "Override: "; str += super.currentLabel; return str; } } }
Le rsultat de linstruction trace() dans le constructeur de la classe OverrideExample est Override: null, ce qui montre que cet exemple a russi redfinir la proprit hritecurrentLabel.

113
Proprits statiques non hrites

Les sous-classes nhritent pas des proprits statiques. Ces dernires ne sont donc pas accessibles par une occurrence dune sous-classe. Une proprit statique nest accessible que par le biais de lobjet classe dans lequel elle est dfinie. Par exemple, le code suivant dfinit une classe de base appele Base et une sous-classe appele Extender, qui tend la classe Base. Une variable statique appele test est dfinie dans la classe Base. Le code de lextrait ci-dessous ne peut tre compil en mode strict et gnre une erreur dexcution en mode standard.
package { import flash.display.MovieClip; public class StaticExample extends MovieClip { public function StaticExample() { var myExt:Extender = new Extender(); trace(myExt.test);// error } } } class Base { public static var test:String = "static"; } class Extender extends Base { }
La seule faon daccder la variable statique test est par lobjet classe, comme le montre le code suivant :
Base.test;
Il est toutefois permis de dfinir une proprit doccurrence ayant le mme nom quune proprit statique. Cette proprit doccurrence peut tre dfinie dans la mme classe que la proprit statique, ou dans une sous-classe. Par exemple, la classe Base de lexemple prcdent peut comporter une proprit doccurrence appele test. Le code suivant peut tre compil et excut normalement, car la classe Extender hrite de la proprit doccurrence. Ce code peut aussi tre compil et excut normalement si la dfinition de la variable doccurrence test est dplace (mais non copie) dans la classe Extender.
package { import flash.display.MovieClip; public class StaticExample extends MovieClip { public function StaticExample() { var myExt:Extender = new Extender(); trace(myExt.test);// output: instance } } } class Base { public static var test:String = "static"; public var test:String = "instance"; } class Extender extends Base {}

114
Proprits statiques et chane de porte

Bien que les proprits statiques ne soient pas hrites, elles figurent dans la chane de porte de la classe qui les dfinit ainsi que de toute sous-classe de celle-ci. Cest pourquoi on dit que les proprits statiques sont dans la porte la fois de la classe dans laquelle elles sont dfinies et des sous-classes de celle-ci. Cela signifie quune proprit statique est directement accessible partir du corps de la classe qui la dfinit et de toute sous-classe de celle-ci. Lexemple suivant modifie les classes dfinies dans lexemple prcdent pour montrer que la variable statique test, dfinie dans la classe Base, est dans la porte de la classe Extender. Autrement dit, la classe Extender peut accder la variable statique test sans quil ne soit ncessaire de faire prcder le nom de celle-ci du nom de la classe qui dfinit test.
package { import flash.display.MovieClip; public class StaticExample extends MovieClip { public function StaticExample() { var myExt:Extender = new Extender(); } } } class Base { public static var test:String = "static"; } class Extender extends Base { public function Extender() { trace(test); // output: static } }
Si une proprit doccurrence est dfinie avec le mme nom quune proprit statique de la mme classe ou dune superclasse, la proprit doccurrence est prioritaire dans la chane de porte. On dit alors que la proprit doccurrence fait de lombre la proprit statique, ce qui signifie que la valeur de la proprit doccurrence est utilise la place de celle de la proprit statique. Par exemple, le code ci-dessous montre que si la classe Extender dfinit une variable doccurrence appele test, linstruction trace() utilise la valeur de la variable doccurrence la place de celle de la variable statique.

115
package { import flash.display.MovieClip; public class StaticExample extends MovieClip { public function StaticExample() { var myExt:Extender = new Extender(); } } } class Base { public static var test:String = "static"; } class Extender extends Base { public var test:String = "instance"; public function Extender() { trace(test); // output: instance } }
Rubriques avances
Historique de la prise en charge de la programmation oriente objets en ActionScript
ActionScript 3.0 est une volution des versions antrieures dActionScript. Cest pourquoi il peut tre utile de comprendre lvolution du modle dobjet en ActionScript. ActionScript tait lorigine un simple mcanisme de script pour les premires versions de Flash Professional. Les programmeurs ont alors commenc dvelopper des applications de plus en plus complexes avec ActionScript. En rponse aux besoins de ces programmeurs, le langage de chaque nouvelle version a connu des ajouts destins faciliter la cration dapplications complexes. ActionScript 1.0 ActionScript 1.0 est le langage utilis dans les versions 6 et antrieures de Flash Player. Mme ce stade prcoce de dveloppement, le modle dobjet dActionScript tait bas sur le concept de lobjet comme type fondamental de donnes. Un objet ActionScript est un type de donnes composite dot dun groupe de proprits. Dans le contexte dun modle dobjet, le terme proprits dsigne tout ce qui est affect un objet (variables, fonctions ou mthodes). Bien que cette premire gnration dActionScript ne prenne pas en charge la dfinition de classes avec le mot-cl
class, elle permet de dfinir une classe laide dun type spcial dobjet appel objet prototype. Au lieu dutiliser un
mot-cl class pour crer une dfinition de classe abstraite qui sera ensuite instancie en objets concrets ( linstar des langages reposant sur des classes, comme Java ou C++), les langages bass sur le prototypage, tel ActionScript 1.0, utilisent un objet existant comme modle (ou prototype) dautres objets. Alors que les objets des langages bass sur la notion de classes peuvent pointer sur une classe qui leur sert de modle, les objets des langages bass sur la notion de prototypes pointent sur un autre objet, leur prototype, qui leur sert de modle.

116
Pour crer une classe en ActionScript 1.0, il est ncessaire de dfinir une fonction constructeur pour cette classe. En ActionScript, les fonctions sont des objets rels et non pas de simples dfinitions abstraites. La fonction constructeur sert alors dobjet prototype pour les occurrences de cette classe. Le code suivant cre une classe appele Shape et dfinit une proprit appele visible qui a la valeur true par dfaut.
// base class function Shape() {} // Create a property named visible. Shape.prototype.visible = true;
Cette fonction constructeur dfinit une classe Shape qui va tre instancie laide de loprateur new, comme suit :
myShape = new Shape();
De mme que lobjet de la fonction constructeur Shape() sert de prototype pour les occurrences de la classe Shape, il peut galement servir pour les sous-classes de Shape, cest--dire dautres classes qui prolongent la classe Shape. La cration dune classe qui est une sous-classe de la classe Shape est un processus en deux tapes. Dabord, crer la classe en dfinissant une fonction constructeur pour cette classe, comme suit :
// child class function Circle(id, radius) { this.id = id; this.radius = radius; }
Ensuite, utiliser loprateur new pour dclarer que la classe Shape est le prototype de la classe Circle. Par dfaut, toute nouvelle classe cre utilise la classe Object comme prototype, si bien que Circle.prototype contient alors un objet gnrique (une occurrence de la classe Object). Pour spcifier que le prototype de Circle est Shape et non pas Object, utilisez le code suivant pour changer la valeur de Circle.prototype afin quelle contienne un objet Shape et non plus un objet gnrique :
// Make Circle a subclass of Shape. Circle.prototype = new Shape();
La classe Shape et la classe Circle sont maintenant lies par une relation dhritage communment appele chanage du prototype. Le schma illustre la relation au sein dun chanage de prototype :
Object.prototype
Shape.prototype
Circle.prototype
La classe de base, la fin de chaque chanage de prototype, est la classe Object. La classe Object contient une proprit statique appele Object.prototype qui pointe sur lobjet prototype de base pour tous les objets crs en ActionScript 1.0. Dans lexemple de chanage de prototype, lobjet suivant est lobjet Shape. En effet, la proprit Shape.prototype na jamais t explicitement dfinie, si bien quelle contient encore un objet gnrique (une occurrence de la classe Object). Le lien final de ce chanage est la classe Circle qui est lie son prototype, la classe Shape (la proprit Circle.prototype contient un objet Shape). Si vous crez une occurrence de la classe Circle, comme dans lexemple ci-dessous, loccurrence hrite du chanage de prototype de la classe Circle :

117
// Create an instance of the Circle class. myCircle = new Circle();
Pour rappel, lexemple contient une proprit appele visible, qui est membre de la classe Shape. La proprit visible nexiste pas comme partie de lobjetmyCircle, mais uniquement comme membre de lobjet Shape ; et pourtant la ligne de code suivante produit la valeur true :
trace(myCircle.visible); // output: true
En remontant le chanage du prototype, le moteur dexcution est en mesure de vrifier que lobjet myCircle hrite de la proprit visible. Lorsque ce code est excut, le moteur dexcution recherche dabord dans les proprits de lobjet myCircle une proprit appele visible, mais ne la trouve pas. Il examine alors lobjet Circle.prototype, mais ne trouve toujours pas la proprit visible. En continuant remonter le chanage du prototype, il finit par trouver la proprit visible dfinie dans lobjet Shape.prototype et affiche sa valeur. Par souci de simplicit, la prsente section omet un grand nombre de dtails et de subtilits du chanage de prototype, puisquil sagit simplement de vous aider comprendre le modle dobjet en ActionScript 3.0. ActionScript 2.0 Avec ActionScript 2.0 ont t introduits de nouveaux mots-cls tels que class, extends, public et private qui permettaient de dfinir des classes selon une mthode bien connue de toute personne ayant travaill avec les langages bass sur des classes, comme Java et C++. Il est important de comprendre que le mcanisme sous-jacent dhritage na pas chang entre ActionScript 1.0 et ActionScript 2.0. Le passage ActionScript 2.0 a consist simplement ajouter une nouvelle syntaxe pour la dfinition des classes. Le chanage du prototype fonctionne de la mme faon dans ces deux versions du langage. La nouvelle syntaxe introduite par ActionScript 2.0 est reprsente dans lexemple ci-dessous. Elle permet de dfinir des classes dune faon que la plupart des programmeurs considrent comme plus intuitive :
// base class class Shape { var visible:Boolean = true; }
Vous pouvez remarquer quActionScript 2.0 a galement introduit les annotations de type destines une vrification des types la compilation. Elles permettent de dclarer que la proprit visible de lexemple prcdent ne doit contenir quune valeur boolenne. Le nouveau mot-cl extends simplifie lui aussi le processus de cration dune sousclasse. Dans lexemple suivant, ce qui ncessitait deux tapes en ActionScript 1.0 est accompli en une seule, laide du mot-cl extends :
// child class class Circle extends Shape { var id:Number; var radius:Number; function Circle(id, radius) { this.id = id; this.radius = radius; } }
Le constructeur est maintenant dclar dans le cadre de la dfinition de classe, et les proprits id et radius de la classe doivent elles aussi tre dclares explicitement.

118
ActionScript 2.0 a galement ajout la prise en charge de la dfinition des interfaces, qui permet de rendre plus perfectionns des programmes orients objet, laide de protocoles formellement dfinis pour la communication entre les objets.
Objet de classe en ActionScript 3.0

Un paradigme courant en programmation oriente objets, en particulier avec Java et C++, fait appel des classes pour dfinir des types dobjets. Les langages de programmation qui adoptent ce paradigme ont aussi tendance utiliser des classes pour construire des occurrences du type de donnes dfini par la classe. ActionScript utilise des classes pour ces deux raisons, mais ses origines de langage bas sur des prototypes lui confrent une caractristique intressante. Pour chaque dfinition de classe, ActionScript cre un objet de classe spcial qui autorise le partage du comportement et de ltat. Toutefois, pour de nombreux programmeurs en ActionScript, cette distinction naura aucune implication pratique sur le codage. En effet, ActionScript 3.0 est conu de telle sorte quil est possible de crer des applications perfectionnes orientes objet sans utiliser, et sans mme comprendre, ces objets de classe spciaux. Le schma suivant montre la structure dun objet de classe reprsentant une classe simple appele A, dfinie par linstruction class A.
Chaque rectangle du schma reprsente un objet. Chaque objet du schma est marqu dun caractre en indice pour signaler quil appartient la classe A. Lobjet de classe (CA) contient des rfrences un certain nombre dautres objets importants. Lobjet traits des occurrences (TA) enregistre les proprits des occurrences qui sont dfinies dans une dfinition de classe. Un objet traits de la classe (TCA) reprsente le type interne de la classe et enregistre les proprits statiques dfinies par la classe (le caractre C en indice signifie classe ). Lobjet prototype (PA) dsigne toujours lobjet de classe auquel il tait associ lorigine par la proprit constructor.
Objet traits
Lobjet traits est une nouveaut dActionScript 3.0, implmente pour des raisons de performances. Dans les versions prcdentes dActionScript, la recherche dun nom pouvait demander beaucoup de temps pendant que Flash Player remontait le chanage du prototype. En ActionScript 3.0, la recherche dun nom est beaucoup plus rapide et efficace, car les proprits hrites sont copies des superclasses dans lobjet traits des sous-classes. Lobjet traits nest pas directement accessible par code, mais sa prsence se manifeste par lamlioration des performances et de lutilisation de la mmoire. Lobjet traits fournit la machine virtuelle AVM2 des informations dtailles sur la disposition et le contenu dune classe. Ces informations permettent AVM2 de rduire nettement le temps dexcution, car elle peut frquemment gnrer des instructions machine directes pour accder des proprits ou appeler des mthodes directement, sans effectuer au pralable une longue recherche de nom.

119
Grce lobjet traits, lespace occup en mmoire par un objet peut tre nettement moins importante quavec les versions antrieures dActionScript. Par exemple, si une classe est scelle (cest--dire si elle nest pas dclare comme dynamique), une occurrence de la classe ne ncessite pas de recherche par calcul dadresse pour les proprits ajoutes dynamiquement ; il lui suffit dun pointeur sur lobjet traits et de quelques emplacements pour les proprits fixes dfinies dans la classe. En consquence, pour un objet qui ncessitait 100 octets en mmoire avec ActionScript 2.0, 20 suffiront avec ActionScript 3.0. Remarque : lobjet traits est un lment dimplmentation interne et il nest pas garanti quil ne changera pas, ou mme quil ne disparatra pas, dans les futures versions dActionScript.
Objet prototype
En ActionScript, chaque objet de classe possde une proprit appele prototype, qui est une rfrence lobjet prototype de cette classe. Lobjet prototype est un hritage des premires versions dActionScript, bases sur des prototypes. Pour plus dinformations, voir Historique de la prise en charge de la programmation oriente objets dans ActionScript. La proprit prototype est en lecture seule et ne peut donc pas tre modifie pour pointer sur dautres objets. A linverse, dans les anciennes versions dActionScript, la proprit prototype pouvait tre raffecte pour pointer sur une autre classe. Bien que la proprit prototype soit en lecture seule, ce nest pas le cas de lobjet prototype laquelle elle fait rfrence. En dautres termes, de nouvelles proprits peuvent tre ajoutes lobjet prototype. Les proprits ajoutes lobjet prototype sont partages avec toutes les autres occurrences de la classe. Le chanage de prototype, qui tait le seul mcanisme dhritage des versions antrieures dActionScript, na plus quun rle secondaire en ActionScript 3.0. Le principal mcanisme dhritage, lhritage des proprits fixes, est gr de faon interne par lobjet traits. Une proprit fixe est une variable ou une mthode dfinie dans le cadre dune dfinition de classe. Lhritage des proprits fixes est galement appel hritage des classes, car cest le mcanisme dhritage qui est associ aux mots-cls class, extends et override. Le chanage de prototype reprsente un autre mcanisme dhritage qui est plus dynamique que lhritage des proprits fixes. Il est possible dajouter des proprits lobjet prototype dune classe, non seulement dans le cadre de la dfinition de classe, mais aussi lors de lexcution, par la proprit prototype de lobjet de classe. Notez toutefois que si le compilateur est en mode strict, il peut tre impossible daccder aux proprits ajoutes un objet prototype, sauf si vous dclarez une classe avec le mot-cl dynamic. La classe Object est un bon exemple dune classe dont plusieurs proprits sont attaches lobjet prototype. Les mthodes toString() et valueOf() de la classe Object sont en fait des fonctions affectes des proprits de lobjet prototype de la classe Object. Voici un exemple de laspect thorique de la dclaration de ces mthodes (limplmentation relle est lgrement diffrente en raison des dtails pratiques dimplmentation) :
public dynamic class Object { prototype.toString = function() { // statements }; prototype.valueOf = function() { // statements }; }
Comme nous lavons dj mentionn, il est possible dattacher une proprit lobjet prototype dune classe en dehors de la dfinition de cette classe. Par exemple, la mthodetoString() peut galement tre dfinie hors de la dfinition de la classe Object, comme suit :

120
Object.prototype.toString = function() { // statements };
Toutefois, contrairement lhritage des proprits fixes, lhritage du prototype ne ncessite pas le mot-cl override pour redfinir une mthode de sous-classe. Par exemple, pour redfinir la mthode valueOf() dans une sous-classe de la classe Object, trois options sont possibles. Premirement, vous pouvez dfinir une mthode valueOf() dans lobjet prototype de la sous-classe, lintrieur de la dfinition de classe. Le code suivant cre une sous-classe dObject appele Foo et redfinit la mthode valueOf() dans la dfinition de classe de lobjet prototype de Foo. Chaque classe hritant de la classe Object, il nest pas ncessaire dutiliser le mot-cl extends.
dynamic class Foo { prototype.valueOf = function() { return "Instance of Foo"; }; }
Deuximement, vous pouvez dfinir une mthode valueOf() dans lobjet prototype de Foo en-dehors de la dfinition de classe, comme le montre le code ci-dessous :
Foo.prototype.valueOf = function() { return "Instance of Foo"; };
Troisimement, vous pouvez dfinir une proprit fixe appele valueOf() dans la classe Foo. Cette technique diffre des prcdentes dans la mesure o elle mle lhritage des proprits fixes lhritage du prototype. Pour redfinir valueOf() partir dune sous-classe de Foo, il est ncessaire dutiliser le mot-cl override. Le code ci-dessous montre valueOf() dfinie comme proprit fixe dans Foo :
class Foo { function valueOf():String { return "Instance of Foo"; } }
Espace de noms dActionScript 3

Lexistence de deux mcanismes dhritage spars, lhritage des proprits fixes et lhritage du prototype, provoque un problme intressant de compatibilit par rapport aux proprits et mthodes des classe de base. La compatibilit avec la spcification du langage ECMAScript sur laquelle est bas ActionScript ncessite lutilisation de lhritage de prototype, si bien que les proprits et les mthodes dune classe de base sont dfinies dans lobjet prototype de cette classe. Mais par ailleurs, la compatibilit avec ActionScript 3.0 ncessite lutilisation de lhritage des proprits fixes, si bien que les proprits et mthodes dune classe de base sont spcifies dans la dfinition de classe, laide des motscls const, var et function. De plus, lutilisation des proprits fixes plutt que les versions du prototype est susceptible de permettre une nette amlioration des performances lexcution. Pour rsoudre ce problme, ActionScript 3.0 utilise les deux mcanismes dhritage (proprits fixes et prototype) pour les classes de base. Chaque classe de base contient deux jeux de proprits et de mthodes. Un jeu est dfini dans lobjet prototype pour assurer la compatibilit avec les spcifications dECMAScript et lautre est dfini avec les proprits fixes et lespace de noms dAS3,0, pour assurer la compatibilit avec ActionScript 3.0.

121
Lespace de noms dAS3 reprsente un mcanisme fort pratique pour choisir entre les deux jeux de proprits et de mthodes. Si vous nutilisez pas lespace de noms dAS3, une occurrence dune classe de base hrite des proprits et des mthodes dfinies dans lobjet prototype de cette classe de base. Si par contre vous utilisez lespace de noms dAS3, une occurrence dune classe de base hrite des versions dAS3, car les proprits fixes sont toujours prfres aux proprits du prototype. En dautres termes, lorsquune proprit fixe est disponible, elle est toujours utilise la place dune proprit du prototype ayant le mme nom. Il est possible dutiliser slectivement la version de lespace de noms dAS3 dune proprit ou dune mthode, en la qualifiant laide de lespace de noms dAS3. Par exemple, le code ci-dessous utilise la version AS3 de la mthode Array.pop() :
var nums:Array = new Array(1, 2, 3); nums.AS3::pop(); trace(nums); // output: 1,2
Vous pouvez aussi faire appel la directive use namespace afin douvrir lespace de noms dAS3 pour toutes les dfinitions figurant dans un bloc de code. Par exemple, le code ci-dessous utilise la directive use namespace afin douvrir lespace de noms dAS3 pour les mthodes pop() et push().
use namespace AS3; var nums:Array = new Array(1, 2, 3); nums.pop(); nums.push(5); trace(nums) // output: 1,2,5
ActionScript 3.0 comporte aussi des options de compilation pour chaque jeu de proprits, ce qui permet dappliquer lespace de noms dAS3 au programme entier. Loption de compilation -as3 reprsente lespace de noms dAS3 et loption de compilation -es reprsente loption dhritage du prototype (es correspond ECMAScript). Pour ouvrir lespace de noms dAS3 pour tout le programme, dfinissez loption de compilation -as3 sur true et loption de compilation -es sur false. Pour utiliser les versions du prototype, dfinissez les options de compilation sur les valeurs opposes. Les options de compilation par dfaut de Flash Builder et Flash Professional sont -as3 = true et -es = false. Si vous prvoyez dtendre lune des classes de base et de redfinir des mthodes, vous devez comprendre comment lespace de noms dAS3 affecte la faon de dclarer une mthode redfinie. Si vous utilisez lespace de noms dAS3, toute redfinition dune mthode dune classe de base doit galement utiliser lespace de noms dAS3, ainsi que lattribut override. Si vous nutilisez pas lespace de noms dAS3 et voulez redfinir une mthode dune classe de base dans une sous-classe, vous ne devez utiliser ni lespace de noms dAS3 dans cette redfinition, ni lattribut override.
Exemple : GeometricShapes
Lexemple dapplication GeometricShapes montre comment il est possible dappliquer un certain nombre de concepts et fonctionnalits orients objet laide dActionScript 3.0 et, en particulier :
Dfinition des classes Extension des classes Polymorphisme et le mot-cl override Dfinition, extension et implmentation des interfaces

122
Cet exemple comprend aussi une mthode usine (Factory) qui cre des occurrences de classes, montrant ainsi comment dclarer une valeur de retour comme occurrence dune interface et utiliser lobjet ainsi renvoy de manire gnrique. Pour obtenir les fichiers de cet exemple dapplication, voir la page www.adobe.com/go/learn_programmingAS3samples_flash_fr. Les fichiers de lapplication GeometricShapes se trouvent dans le dossier Samples/GeometricShapes. Lapplication se compose des fichiers suivants :
Fichier GeometricShapes.mxml ou GeometricShapes.fla com/example/programmingas3/geometricshapes/IGeometricShape.as Interface de base dfinissant les mthodes qui doivent tre implmentes par toutes les classes de lapplication GeometricShapes. Interface dfinissant les mthodes qui doivent tre implmentes par les classes de lapplication GeometricShapes qui comportent plusieurs cts. Type de forme gomtrique dont les cts sont de longueur gale et positionns symtriquement autour du centre de la forme. Type de forme gomtrique qui dfinit un cercle. Sous-classe de RegularPolygon qui dfinit un triangle quilatral. Sous-classe de RegularPolygon qui dfinit un carr. Classe contenant une mthode usine (Factory) pour crer des formes partir dun type et dune taille de forme. Description Le fichier dapplication principal dans Flash (FLA) ou Flex (MXML).
com/example/programmingas3/geometricshapes/IPolygon.as
com/example/programmingas3/geometricshapes/RegularPolygon.as
com/example/programmingas3/geometricshapes/Circle.as com/example/programmingas3/geometricshapes/EquilateralTriangle.as
com/example/programmingas3/geometricshapes/Square.as
com/example/programmingas3/geometricshapes/GeometricShapeFactory.as
Dfinition des classes de GeometricShapes

Lapplication GeometricShapes permet de spcifier un type de forme gomtrique et la taille de cette dernire. Elle renvoie alors la description de la forme, sa surface et son primtre. Linterface utilisateur de lapplication est banale : elle se compose de quelques contrles permettant de slectionner le type de forme, de dfinir la taille et dafficher la description. De fait, la partie intressante de cette application est la face cache de liceberg : la structure des classes et des interfaces elles-mmes. Cette application traite des formes gomtriques, mais elle ne les affiche pas graphiquement. Les classes et interfaces qui dfinissent les formes gomtriques de cet exemple sont reprsentes dans le schma cidessous, en notation UML (Unified Modeling Language) :

123
<<interface>> IGeometricShape +getArea():Number +describe():String
<<interface>> IPolygon +getPerimeter():Number +getSumOfAngles ():Number
Circle +diameter:Number
+Circle () : Circle +getArea () : Number +describe () : String +getCircumference
RegularPolygon
+num Sides : int +sideLength : Number
+RegularPolygon (): RegularPolygon +getSumOfAngles (): Number +getPerimeter (): Number +getArea (): Number +describe (): Stri ng
():Number
EquilateralTriangle
+EquilateralTriangle (): EquilateralTriangle +getArea (): Number +describe (): String
Square +Square():Square +getArea():Number +des cribe () :String
GeometricShapes Example Classes
Dfinition dun comportement commun laide dinterfaces

Cette application GeometricShapes gre trois types de formes : cercles, carrs et triangles quilatraux. La structure des classes de GeometricShapes commence par une interface trs simple, IGeometricShape, qui rpertorie des mthodes communes aux trois types de formes :
package com.example.programmingas3.geometricshapes { public interface IGeometricShape { function getArea():Number; function describe():String; } }
Linterface dfinit deux mthodes : la mthode getArea() qui calcule et renvoie la surface de la forme, et la mthode describe() qui assemble une description textuelle des proprits de la forme. Il est aussi souhaitable de connatre le primtre de chaque forme. Toutefois, le primtre dun cercle est appel circonfrence et il est calcul de faon particulire, si bien que le comportement diverge de ceux dun triangle ou dun carr. Il existe cependant assez de similitudes entre les triangles, les carrs et les autres polygones pour quil soit logique de dfinir une nouvelle classe dinterface pour eux : IPolygon. Linterface IPolygon est galement plutt simple, comme on peut le constater :

124
package com.example.programmingas3.geometricshapes { public interface IPolygon extends IGeometricShape { function getPerimeter():Number; function getSumOfAngles():Number; } }
Cette interface dfinit deux mthodes communes tous les polygones : la mthode getPerimeter() qui mesure la longueur combine de tous les cts et la mthode getSumOfAngles() qui additionne tous les angles intrieurs. Linterface IPolygon tend linterface IGeometricShape, si bien que toute classe qui implmente linterface IPolygon doit dclarer les quatre mthodes : les deux de linterface IGeometricShape et les deux de linterface IPolygon.
Dfinition des classes de formes

Ds que vous avez une vue claire des mthodes communes chaque type de forme, vous pouvez dfinir les classes de formes elles-mmes. En ce qui concerne le nombre de mthodes implmenter, la forme la plus simple est la classe Circle :
package com.example.programmingas3.geometricshapes { public class Circle implements IGeometricShape { public var diameter:Number; public function Circle(diam:Number = 100):void { this.diameter = diam; } public function getArea():Number { // The formula is Pi * radius * radius. var radius:Number = diameter / 2; return Math.PI * radius * radius; } public function getCircumference():Number { // The formula is Pi * diameter. return Math.PI * diameter; } public function describe():String { var desc:String = "This shape is a Circle.\n"; desc += "Its diameter is " + diameter + " pixels.\n"; desc += "Its area is " + getArea() + ".\n"; desc += "Its circumference is " + getCircumference() + ".\n"; return desc; } } }

125
La classe Circle implmente linterface IGeometricShape. Elle doit donc comporter du code pour les mthodes getArea() et describe(). De plus, elle dfinit la mthode getCircumference() qui est unique la classe Circle. La classe Circle dclare aussi une proprit, diameter, qui napparatra pas dans les autres classes, ddies aux polygones. Les deux autres types de formes, les carrs et les triangles quilatraux, ont dautres points communs : ils ont tous deux des cts de longueur gale et il existe des formules communes pour calculer leurs primtre et la somme de leurs angles intrieurs. En fait, ces formules communes sappliquent tout autre polygone rgulier que vous dfinissez par la suite. La classe RegularPolygon est la superclasse de la classe Square et de la classe EquilateralTriangle. Une superclasse permet de dfinir en un seul point des mthodes communes. Il nest donc pas ncessaire de les dfinir sparment dans chaque sous-classe. Voici le code de la classe RegularPolygon :
package com.example.programmingas3.geometricshapes { public class RegularPolygon implements IPolygon { public var numSides:int; public var sideLength:Number; public function RegularPolygon(len:Number = 100, sides:int = 3):void { this.sideLength = len; this.numSides = sides; } public function getArea():Number { // This method should be overridden in subclasses. return 0; } public function getPerimeter():Number { return sideLength * numSides; } public function getSumOfAngles():Number { if (numSides >= 3)

126
{ return ((numSides - 2) * 180); } else { return 0; } } public function describe():String { var desc:String = "Each side is " + sideLength + " pixels long.\n"; desc += "Its area is " + getArea() + " pixels square.\n"; desc += "Its perimeter is " + getPerimeter() + " pixels long.\n"; desc += "The sum of all interior angles in this shape is " + getSumOfAngles() + " degrees.\n"; return desc; } } }
La classe RegularPolygon dclare dabord deux proprits qui sont communes tous les polygones rguliers : la longueur de chaque ct (la proprit sideLength) et le nombre de faces (la proprit numSides). La classe RegularPolygon implmente linterface IPolygon et dclare les quatre mthodes de linterface IPolygon. Elle implmente deux dentre elles, les mthodes getPerimeter() et getSumOfAngles() laide de formules communes. La formule de la mthode getArea() tant diffrente dune forme lautre, la version de la mthode dans la classe de base ne peut pas comporter une logique commune dont hriteraient les mthodes des sous-classes. Elle renvoie donc simplement une valeur 0 par dfaut pour indiquer que la surface na pas t calcule. Pour calculer correctement la surface de chaque forme, les sous-classes de la classe RegularPolygon doivent redfinir elles-mmes la mthode getArea(). Le code de la classe EquilateralTriangle, ci-dessous, montre comment la mthode getArea() :

127
package com.example.programmingas3.geometricshapes { public class EquilateralTriangle extends RegularPolygon { public function EquilateralTriangle(len:Number = 100):void { super(len, 3); } public override function getArea():Number { // The formula is ((sideLength squared) * (square root of 3)) / 4. return ( (this.sideLength * this.sideLength) * Math.sqrt(3) ) / 4; } public override function describe():String { /* starts with the name of the shape, then delegates the rest of the description work to the RegularPolygon superclass */ var desc:String = "This shape is an equilateral Triangle.\n"; desc += super.describe(); return desc; } } }
Le mot-cl override indique que la mthode EquilateralTriangle.getArea() redfinit volontairement la mthode getArea() de la superclasse RegularPolygon. Lorsque la mthode EquilateralTriangle.getArea() est appele, elle calcule la surface laide de la formule du code prcdent. Le code de la mthode RegularPolygon.getArea() nest jamais excut. Par contre, la classe EquilateralTriangle ne dfinit pas sa propre version de la mthodegetPerimeter(). Lorsque la mthode EquilateralTriangle.getPerimeter() est appele, lappel remonte la chane dhritage et excute le code de la mthode getPerimeter() de la superclasse RegularPolygon. Le constructeur EquilateralTriangle() utilise linstruction super() pour invoquer explicitement le constructeur
RegularPolygon() de sa superclasse. Si les deux constructeurs avaient le mme ensemble de paramtres, il serait
possible domettre compltement le constructeur EquilateralTriangle et il suffirait dexcuter le constructeur

RegularPolygon(). Toutefois, le constructeur RegularPolygon() ncessite un paramtre supplmentaire, numSides. Le constructeur EquilateralTriangle() appelle donc super(len, 3) qui transmet le paramtre en entre len et la valeur 3 pour indiquer que le triangle possde trois cts.
La mthode describe() utilise galement linstruction super(), mais de faon diffrente, afin dappeler la version de la mthode describe() figurant dans la superclasse RegularPolygon. La mthode EquilateralTriangle.describe() dfinit dabord la variable de chane desc qui affiche le type de forme. Elle obtient ensuite les rsultats de la mthode RegularPolygon.describe() en appelant super.describe() et elle ajoute ces rsultats la fin de la chane desc. La classe Square nest pas dcrite en dtail ici, mais elle est similaire la classe EquilateralTriangle, avec un constructeur et ses propres implmentations des mthodes getArea() et describe().

128
Polymorphisme et mthode usine (Factory)

Il est possible dutiliser de diverses faons intressantes un ensemble de classes qui utilisent bon escient les interfaces et lhritage. Par exemple, toutes les classes de formes dcrites jusquici implmentent linterface IGeometricShape ou tendent une superclasse qui se charge de cette implmentation. Si vous dfinissez une variable comme tant une occurrence de IGeometricShape, il nest pas ncessaire, pour appeler sa mthode describe(), de savoir si cest une occurrence de la classe Circle ou de la classe Square. Le code suivant illustre cette situation :
var myShape:IGeometricShape = new Circle(100); trace(myShape.describe());
Lorsque myShape.describe() est appele, elle excute la mthode Circle.describe(); car bien que la variable soit dfinie comme une occurrence de linterface IGeometricShape, Circle est sa classe sous-jacente. Cet exemple illustre le principe du polymorphisme : le mme appel une mthode provoquera lexcution dun code diffrent, selon la classe de lobjet dont la mthode est appele. Lapplication GeometricShapes applique ce type de polymorphisme bas sur linterface laide dune version simplifie dun modle de conception appel mthode usine (Factory). Lexpression mthode usine (Factory) dsigne une fonction qui renvoie un objet dont le type de donnes sous-jacent ou le contenu diffrent selon le contexte. La classe GeometricShapeFactory reprsente ici dfinit une mthode usine (Factory) appele createShape() :
package com.example.programmingas3.geometricshapes { public class GeometricShapeFactory { public static var currentShape:IGeometricShape; public static function createShape(shapeName:String, len:Number):IGeometricShape { switch (shapeName) { case "Triangle": return new EquilateralTriangle(len); case "Square": return new Square(len); case "Circle": return new Circle(len); } return null; } public static function describeShape(shapeType:String, shapeSize:Number):String { GeometricShapeFactory.currentShape = GeometricShapeFactory.createShape(shapeType, shapeSize); return GeometricShapeFactory.currentShape.describe(); } } }

129
La mthode usine (Factory) createShape() laisse aux constructeurs de la sous-classe de la forme le soin de dfinir les dtails des occurrences quils crent, tout en renvoyant les nouveaux objets comme occurrences de IgeometricShape, ce qui permet lapplication de les traiter de faon plus gnrale. La mthode describeShape() de lexemple prcdent montre comment une application peut utiliser la mthode usine (Factory) pour obtenir une rfrence gnrique un objet spcifique. Lapplication peut obtenir la description dun objet Circle nouvellement cr en procdant comme suit :
GeometricShapeFactory.describeShape("Circle", 100);
La mthode describeShape() appelle alors la mthode usine (Factory) createShape() avec les mmes paramtres. Elle met le nouvel objet Circle dans une variable statique appele currentShape, dont le type a t dfini comme objet de IGeometricShape. La mthode describe() est ensuite appele pour lobjet currentShape et cet appel est automatiquement rsolu pour excuter la mthode Circle.describe() qui renvoie une description dtaille du cercle.
Amlioration de lapplication dexemple

La puissance des interfaces et de lhritage devient vidente ds quil sagit de modifier lapplication. Supposons que nous voulions ajouter une nouvelle forme, un pentagone, cette application. Il suffit de crer une classe, Pentagon, qui tend la classe RegularPolygon et dfinit ses propres versions des mthodes getArea() et describe(). Une nouvelle option Pentagon est ensuite ajoute dans linterface utilisateur de lapplication. Cest tout. La classe Pentagon obtiendra automatiquement, par hritage, les fonctionnalits des mthodes getPerimeter() et getSumOfAngles() de la classe RegularPolygon. Et puisquelle hrite dune classe qui implmente linterface IGeometricShape, une occurrence de Pentagon sera galement traite comme une occurrence de IGeometricShape. Autrement dit, il nest pas ncessaire de modifier lune des mthodes de la classe GeometricShapeFactory, ce qui rend beaucoup plus facile lajout ultrieur de nouveaux types de forme. Par consquent, il nest pas ncessaire non plus de modifier le code qui utilise la classe GeometricShapeFactory. A titre dexercice, il est conseill dajouter une classe Pentagon lexemple Geometric Shapes, afin de constater quel point les interfaces et lhritage facilitent le processus dajout de nouvelles fonctionnalits une application.

As3 Learning

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

As3 Learning

Uploaded by

Copyright:

Available Formats

Formation

Dernire mise jour le 16/5/2011

Exemple : Cration dune application de base

Dernire mise jour le 16/5/2011

Chapitre 1 : Introduction ActionScript 3.0

Avantages dActionScript 3.0

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Nouveauts dActionScript 3.0

Fonctions du langage de base

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Dernire mise jour le 16/5/2011

Chapitre 2 : Prise en main dActionScript

Quel est le rle dun programme informatique ?

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

La valeur relle stocke dans la mmoire de lordinateur

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Utilisation des objets

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Proprits Mthodes Evnements

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Gestion des vnements de base

Rponse : quelles actions doivent tre excutes lorsque lvnement se produit ?

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Processus de gestion dvnement

Voici comment ce code devrait fonctionner lorsquil est excut :

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

comme MouseEvent.CLICK dans le code).

A ce stade, les oprations suivantes ont lieu :

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Exemples de gestion dvnements

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Cration doccurrences dobjets

Valeur numrique littrale (entrez le nombre directement) :

Valeur de chane littrale (entourez le texte de doubles guillemets) :

Valeur boolenne littrale (utilisez la valeur littrale true ou false) :

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Valeur XML littrale (entrez le XML directement) :

Elments de programme courants

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Exemple : Elment de portfolio danimation (Flash Professional)

Dernire mise jour le 16/5/2011

FORMATION ACTIONSCRIPT 3.0

Prparation lajout dinteractivit

vous ajouterez les boutons.

ActionScript votre application.

Cration et ajout de boutons